[LCP]moving folder contents from one m/c to another
Kurian Abraham Kurian Abraham-A18108
kurian.abraham at motorola.com
Sun Dec 22 06:42:02 UTC 2002
hi
where can i get the linux source code for free() function
regds
kurian
-----Original Message-----
From: mehul radheshyam choube [mailto:mrc_cprog at rediffmail.com]
Sent: Tuesday, December 17, 2002 1:03 PM
To: linuxcprogramming at lists.linux.org.au
Subject: [LCP]moving folder contents from one m/c to another
hi friends,
i want to move folder contents from one m/c(client) to another
m/c(server). for this i have written two programs client.c and
server.c.
for this there can be two approches :-
(a) client sends file wait for ack from server and on recieving
ack send
next file.
(b) client just pushes the all the files and the server reads
the
contents. no ack in this approach.
i m trying 2nd approach but it doesnt work. here i have
decided
for a delimeter which is '\012'(LF). the cliebt send file name
ending
with LF, hen send file perms ending with LF then sends file size
ending
with LF and last the file contents ending with LF.
please go through the code and reply.
mehul.
/************************ client.c
*******************************/
#include <time.h>
#include <stdio.h>
#include <netdb.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define PORT 8000
#define BACKLOG 10
#define ERR_REPORT "client"
#define DOUGNET_VERSION "1.0"
#define CVS_OK_SEND_FILES "100 Ok; send files.\n"
/*
* Sends a string 'buf' on the descriptor sd. Returns the number
of
* bytes written, or -1 if an error occured.
*/
int sendstring(int sd, char *buf)
{
return write(sd, buf, strlen(buf));
}/* sendstring() */
/*
* This will close the socket 'sd'. Returns -1 on error, 0 on
success.
*/
int closesock(int sd)
{
return close(sd);
}/* closesock() */
/*
* This will return a new socket connected to the host specified
in
* 'toconn' (can be an IP or a DNS name) on the port 'port'.
Returns
* NULL if unsuccessful.
*/
int openconnection(char *toconn, int port)
{
struct hostent *he;
struct sockaddr_in their_addr; /* connector's address
information */
int sd, res;
he = gethostbyname(toconn); /* get the host info */
if(NULL == he) {
#ifdef ERR_REPORT
fprintf(stderr,"%s: Unable to lookup
host!\n", ERR_REPORT);
#endif
return (int) NULL;
}/* if(NULL == he) */
sd = socket(AF_INET, SOCK_STREAM, 0);
if(sd == -1) {
#ifdef ERR_REPORT
fprintf(stderr,"%s: Unable to create
connection socket!\n", ERR_REPORT);
#endif
return (int) NULL;
}/* if(sd == -1) */
their_addr.sin_family = AF_INET; /* host byte
order */
their_addr.sin_port = htons(port); /* short, network
byte order */
their_addr.sin_addr = *((struct in_addr
*)he->h_addr);
bzero(&(their_addr.sin_zero), 8); /* zero the rest of
the struct */
res = connect(sd, (struct sockaddr *)&their_addr,
sizeof(struct sockaddr));
if(res == -1) {
#ifdef ERR_REPORT
fprintf(stderr, "%s: Unable to create
connection to %s!\n", ERR_REPORT, toconn);
#endif
return (int) NULL;
}/* if(res == -1) */
return sd;
}/* openconnection() */
int GetFileSize(const char *file)
{
int fileSize = 0;
struct stat st;
int retVal;
retVal = lstat(file,&st);
if(retVal < 0) {
return -1;
}/* if(retVal < 0) */
fileSize = st.st_size;
return fileSize;
}/* GetFileSize() */
/*
* checks whether a folder exists.
* return 1 if folder exists else 0.
*/
int isDir(char *dirName)
{
DIR *dt = NULL;
dt = opendir(dirName);
if(NULL == dt) {
return 0;
}/* if(NULL == dt) */
closedir(dt);
return 1;
}/* isDir() */
/*
* sends folder contents.
* if successful returns 1 else 0.
*/
int sendDirContents(int s, char *dirName)
{
DIR *dp;
char fileName[256 + 1];
struct dirent *d;
dp = opendir(dirName);
if(NULL == dp) {
printf("ERROR unable to open %s directory, at
line %d of file %s %s.\n", dirName,__LINE__, __FILE__,
strerror(errno));
return 0;
}/* if(NULL == dp) */
while((d = readdir(dp)) != NULL) {
int fileSize, retStatus;
char str[10];
char cmd[1025];
FILE *fp = NULL;
if( !( strcmp(d->d_name,".") ) || !(
strcmp(d->d_name,"..") ) ) {
continue;
}/* if( !( strcmp(d->d_name,".") ) || !(
strcmp(d->d_name,"..") ) ) */
sprintf(fileName,"%s/%s",dirName,d->d_name);
retStatus = isDir(fileName);
if(retStatus) {
/* folder */
int res = sendDirContents(s, fileName);
if(!res) {
return 0;
}/* if(!res) */
}/* if(retStatus) */
sendstring(s, fileName);
sendstring(s,"\012");
sendstring(s, "u=rw,g=r,o=r");
sendstring(s,"\012");
fileSize = GetFileSize(fileName);
memset(str, 0, sizeof(str));
sprintf(str, "%d", fileSize);
sendstring(s, str);
sendstring(s, "\012");
printf("fileName = %s str = %s\n", fileName,
str);
fp = fopen(fileName,"rb");
if(NULL == fp) {
return;
}/* if(NULL == fp) */
while(!feof(fp)) {
int bytesRead;
memset(cmd, 0, 1024);
bytesRead = fread(cmd, 1, 1024, fp);
cmd[bytesRead] = 0;
sendstring(s, cmd);
printf("cmd = %s strlen(cmd) = %d
bytesRead = %d\n", cmd, strlen(cmd), bytesRead);
}/* while(!feof(fp)) */
fclose(fp);
}/* while((d = readdir(dp)) != NULL) */
closedir(dp);
return 1;
}/* sendDirContents() */
int main (int argc, char *argv[])
{
int s, res;
char tpbuf[100];
char dirName[50];
char *str = NULL;
if(argc != 3) {
fprintf(stderr, "Usage: client <server IP
Address> <folder full path>\n");
exit(0);
}/* if(argc != 3) */
s = openconnection(argv[1], PORT);
if(s == (int) NULL) {
fprintf(stderr, "client: Unable to connect to %s
on port %d!\n", argv[1], PORT);
exit(0);
}/* if(s == (int) NULL) */
bzero(dirName, sizeof(dirName));
str = (char *)strrchr(argv[2], '/');
if(NULL == str) {
strncpy(dirName, argv[2], strlen(argv[2]));
}/* if(NULL == str) */
else {
strncpy(dirName, (str + 1), strlen((str + 1)));
*str = '\0';
if(chdir(argv[2]) != 0) {
printf("Error : cannot chdir to %s (error
%s)!\n", argv[2], strerror(errno));
}/* if(chdir(argv[2]) != 0) */
}/* else for if(NULL == str) */
printf("dirName = %s\n", dirName);
sendstring(s, dirName);
sendstring(s, "\012");
res = sendDirContents(s, dirName);
if(!res) {
printf("unable to send contents of dir %s\n",
dirName);
}/* if(!res) */
sendstring(s, "Finished sending.");
sendstring(s, "\012");
closesock(s);
return 0;
}/* main() */
/************************ client.c
*******************************/
/************************ server.c
*******************************/
#include <time.h>
#include <netdb.h>
#include <stdio.h>
#include <errno.h>
#include <dirent.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define PORT 8000
#define BACKLOG 10
#define ERR_REPORT "server"
#define DOUGNET_VERSION "1.0"
/* Permission Modes required when creating dir */
#define DIR_PERM (S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP |
S_IROTH)
#define ownerRead 0400
#define ownerWrite 0200
#define ownerExecute 0100
#define groupRead 040
#define groupWrite 020
#define groupExecute 010
#define othersRead 04
#define othersWrite 02
#define othersExecute 01
#define CVS_BASE_PATH "/usr/kalinga/tmp"
#define CVS_FINISHED_SENDING "Finished sending."
/*
* Will immediatley return a positive value when sd gets data on
it.
* It will wait up to ustimeout microseconds, and return 0 if
no
* data is waiting on the socket.
*/
int pollsocket(int sd, long ustimeout)
{
fd_set rfds;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = ustimeout;
FD_ZERO(&rfds);
FD_SET(sd, &rfds);
select(FD_SETSIZE, &rfds, NULL, NULL, &tv);
return FD_ISSET(sd, &rfds);
}/* pollsocket() */
/*
* Will accept a waiting connection on 'listenfd', and return
this new
* socket. It will return NULL if unsuccessful.
* If 'theirip' isn't NULL, it will copy the dotted quad notation
IP
* address (eg 192.168.23.4) into 'theirip'. Make sure 'theirip'
can
* contain at least 16 characters.
*/
int acceptfromlistener(int listenfd, char *theirip)
{
struct sockaddr_in their_addr;
int tp = sizeof(struct sockaddr_in);
int connfd;
if(!pollsocket(listenfd, 0)) {
return -1;
}/* if(!pollsocket(listenfd, 0)) */
connfd = accept(listenfd, (struct sockaddr *)&their_addr,
&tp);
if(connfd == -1) {
#ifdef ERR_REPORT
fprintf(stderr, "%s: Unable to accept
connection!\n", ERR_REPORT);
#endif
return (int) NULL;
}/* if(connfd == -1) */
if(theirip != NULL) {
snprintf(theirip, 16, "%s",
inet_ntoa(their_addr.sin_addr));
}/* if(theirip != NULL) */
return connfd;
}/* acceptfromlistener() */
/* This will close the socket 'sd'. Returns -1 on error, 0 on
success. */
int closesock(int sd)
{
return close(sd);
}/* closesock() */
/* This will start listening on port 'port', and return this new
socket.
* Returns NULL if unsuccessful. */
int openlistener(int port)
{
int tp, sd;
struct sockaddr_in my_addr;
int res;
sd = socket(AF_INET, SOCK_STREAM, 0);
if(sd == -1) {
#ifdef ERR_REPORT
fprintf(stderr,"%s: Unable to create
server socket!\n", ERR_REPORT);
#endif
return (int) NULL;
}/* if(sd == -1) */
/*
* This excellent bugfix added by Fabrice Marie to
Anti-Web.
*/
res = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &tp,
sizeof(tp));
if(res == -1) {
#ifdef ERR_REPORT
fprintf(stderr, "%s: Unable to
setsockopt()s. Non-fatal.\n", ERR_REPORT);
#endif
}/* if(res == -1) */
my_addr.sin_family = AF_INET; /* host byte
order */
my_addr.sin_port = htons(port); /* short,
network byte order */
my_addr.sin_addr.s_addr = INADDR_ANY;/* automatically
fill with my IP */
memset(&(my_addr.sin_zero), 0, 8); /* zero the rest of
the struct */
res = bind(sd, (struct sockaddr *)&my_addr, sizeof(struct
sockaddr));
if(res == -1) {
#ifdef ERR_REPORT
fprintf(stderr,"%s: Unable to bind!\n",
ERR_REPORT);
#endif
return (int) NULL;
}/* if(res == -1) */
if(listen(sd, BACKLOG) == -1) {
#ifdef ERR_REPORT
fprintf(stderr,"%s: Unable to listen!\n",
ERR_REPORT);
#endif
return (int) NULL;
}/* if(listen(sd, BACKLOG) == -1) */
return sd;
}/* openlistener() */
/*
* Read a line from socket SOCK. Result does not include the
* terminating linefeed.
* Returns number of bytes read.
*/
static int recv_line (int sock, char **resultp)
{
char *result;
size_t input_index = 0;
size_t result_size = 80;
result = (char *)malloc(result_size);
if(NULL == result) {
return 0;
}/* if(NULL == result) */
bzero(result, result_size);
while(1) {
char ch;
int n;
n = recv (sock, &ch, 1, 0);
if(n <= 0) {
printf("recv() from server\n");
}/* if(n <= 0) */
if(ch == '\012') {
break;
}/* if(ch == '\012') */
result[input_index++] = ch;
while(input_index + 1 >= result_size) {
result_size *= 2;
result = (char *) realloc(result,
result_size);
if(NULL == result) {
return 0;
}/* if(NULL == result) */
bzero(&result[input_index], (result_size
- input_index));
}/* while(input_index + 1 >= result_size) */
}/* while(1) */
/*
* Terminate it just for kicks, but we *can* deal with
embedded NULs.
*/
result[input_index] = '\0';
if(resultp) {
*resultp = result;
}/* if(resultp) */
return input_index;
}/* recv_line () */
/*
* checks whether a folder exists.
* return 1 if folder exists else 0.
*/
int isDir(char *dirName)
{
DIR *dt = NULL;
dt = opendir(dirName);
if(NULL == dt) {
return 0;
}/* if(NULL == dt) */
closedir(dt);
return 1;
}/* isDir() */
/*
* creates folder.
* returns 1 if successful else 0.
*/
int createDir(char *dirName)
{
int retStatus;
char *str = NULL, *str1 = NULL;
char *name = NULL, *name1 = NULL;
int bytes = 0;
if(!dirName) {
return 0;
}/* if(!dirName) */
str = str1 = name1 = dirName;
printf("str = %s strlen(str) = %d\n", str,
strlen(str));
while(name1 != NULL) {
name1 = (char *)strchr(str,'/');
if(NULL == name1) {
bytes = strlen(str1);
}/* if(NULL == name1) */
else {
bytes = strlen(str1) - strlen(name1);
printf("name1 = %s\n", name1);
}/* else for if(NULL == name1) */
printf("bytes = %d\n", bytes);
name = (char *)malloc((bytes + 1) *
sizeof(char));
if(NULL == name) {
return 0;
}/* if(NULL == name) */
strncpy(name, str1, bytes);
name[bytes] = '\0';
printf("name = %s\n", name);
if(!isDir(name)) {
retStatus = mkdir(name, DIR_PERM);
if(retStatus != 0) {
printf("%s\n",
strerror(errno));
return 0;
}/* if(retStatus != 0) */
}/* if(!isDir(name)) */
if(name1) {
if(strlen(name1) == 1) {
name1 = NULL;
}/* if(strlen(name1) == 1) */
else {
str = name1 + 1;
}/* else for if(strlen(name1) == 1) */
free(name);
name = NULL;
}/* if(name1) */
}/* while(str != NULL) */
return 1;
}/* createDir() */
/*
* change mode of the file.
* if successful returns 1 else 0 value.
*/
int changeMod(char *fName, char *modeStr)
{
mode_t mode = 0;
FILE *fp = NULL;
char *ptr = NULL;
int ownerFlag = 0, groupFlag = 0, othersFlag = 0;
int retStatus = 0;
fp = fopen(fName,"wb");
if(NULL == fp) {
return 0;
}/* if(NULL == fp) */
fclose(fp);
ptr = modeStr;
for(;*ptr;ptr++) {
if((*ptr == '=') || (*ptr == ',')) {
continue;
}/* if((*ptr == '=') || (*ptr == ',')) */
if(*ptr == 'u') {
ownerFlag = 1;
groupFlag = 0;
othersFlag = 0;
}/* if(*ptr == 'u') */
if(*ptr == 'g') {
ownerFlag = 0;
groupFlag = 1;
othersFlag = 0;
}/* if(*ptr == 'g') */
if(*ptr == 'o') {
ownerFlag = 0;
groupFlag = 0;
othersFlag = 1;
}/* if(*ptr == 'o') */
if(*ptr == 'r') {
if(ownerFlag) {
mode = mode + ownerRead;
}/* if(ownerFlag) */
else if(groupFlag) {
mode = mode + groupRead;
}/* else if(groupFlag) */
else if(othersFlag) {
mode = mode + othersRead;
}/* else if(othersFlag) */
}/* if(*ptr == 'r') */
if(*ptr == 'w') {
if(ownerFlag) {
mode = mode + ownerWrite;
}/* if(ownerFlag) */
else if(groupFlag) {
mode = mode + groupWrite;
}/* else if(groupFlag) */
else if(othersFlag) {
mode = mode + othersWrite;
}/* else if(othersFlag) */
}/* if(*ptr == 'r') */
if(*ptr == 'x') {
if(ownerFlag) {
mode = mode + ownerExecute;
}/* if(ownerFlag) */
else if(groupFlag) {
mode = mode + groupExecute;
}/* else if(groupFlag) */
else if(othersFlag) {
mode = mode + othersExecute;
}/* else if(othersFlag) */
}/* if(*ptr == 'r') */
}/* for(;ptr;) */
retStatus = chmod(fName, mode);
if(retStatus != 0) {
return 0;
}/* if(retStatus != 0) */
return 1;
}/* changeMod() */
/*
* gets file contents from the client.
* if successful returns 1 else 0 value.
*/
int getFileContents(int sock, char *fName, int bytes)
{
FILE *fp = NULL;
int cnt = 0, len, bytesWritten;
char *cmd = NULL;
int a;
char ch;
int n;
fp = fopen(fName,"wb");
if(NULL == fName) {
return 0;
}/* if(NULL == fName) */
while(cnt < bytes) {
n = recv (sock, &ch, 1, 0);
if(n <= 0) {
printf("recv() from server\n");
}/* if(n <= 0) */
bytesWritten = fwrite(&ch, 1, n, fp);
if(bytesWritten != n) {
if(fp) {
fclose(fp);
}/* if(fp) */
if(cmd) {
free(cmd);
cmd = NULL;
}/* if(cmd) */
return 0;
}/* if(bytesWritten != n) */
printf("cnt = %d\n", cnt);
cnt = cnt + n;
printf("cnt = %d\n", cnt);
}/* while(cnt < bytes) */
printf("file name = %s\n", fName);
printf("bytes = %d\n", bytes);
/* scanf("%d", &a); */
if(fp) {
fclose(fp);
}/* if(fp) */
return 1;
}/* getFileContents() */
/*
* gets contents of a folder.
* including contents of subfolders.
* returns 1 if successful else 0.
*/
int getDirContents(int sock, char *basePath, char *dirName)
{
char fullPath[256];
int res;
int exitFlag = 0;
int a;
bzero(fullPath, sizeof(fullPath));
sprintf(fullPath, "%s/%s", basePath, dirName);
printf("fullPath = %s\n", fullPath);
if(chdir(basePath) != 0) {
printf("Error : cannot chdir to %s (error %s)!\n",
basePath, strerror(errno));
}/* if(chdir(basePath) != 0) */
res = createDir(dirName);
if(!res) {
printf("unable to create folder %s\n", dirName);
return 0;
}/* if(!res) */
while(1) {
char *fileName, *filePerms, *fileSize;
char *str = NULL;
int fSize;
if(exitFlag) {
break;
}/* if(exitFlag) */
recv_line(sock, &fileName);
/* strstr(fileName, "pfds[") && (strstr(fileName,
"].events") || strstr(fileName, "].fd")) */
res = strcasecmp(fileName, CVS_FINISHED_SENDING);
if(!res) {
exitFlag = 1;
if(fileName) {
free(fileName);
fileName = NULL;
}/* if(fileName) */
if(filePerms) {
free(filePerms);
filePerms = NULL;
}/* if(filePerms) */
if(fileSize) {
free(fileSize);
fileSize = NULL;
}/* if(fileSize) */
continue;
}/* if(!res) */
printf("fileName = %s\n", fileName);
str = (char *)strrchr(fileName, '/');
if(NULL != str) {
char *path = (char *)malloc(sizeof(char) *
strlen(fileName) - strlen(str) + 1);
if(NULL == path) {
exitFlag = 1;
if(fileName) {
free(fileName);
fileName = NULL;
}/* if(fileName) */
if(filePerms) {
free(filePerms);
filePerms = NULL;
}/* if(filePerms) */
if(fileSize) {
free(fileSize);
fileSize = NULL;
}/* if(fileSize) */
continue;
}/* if(NULL == path) */
memset(path, 0, strlen(fileName) - strlen(str) +
1);
strncpy(path, fileName, strlen(fileName) -
strlen(str) + 1);
res = createDir(path);
if(!res) {
printf("unable to create folder %s\n", path);
exitFlag = 1;
if(fileName) {
free(fileName);
fileName = NULL;
}/* if(fileName) */
if(filePerms) {
free(filePerms);
filePerms = NULL;
}/* if(filePerms) */
if(fileSize) {
free(fileSize);
fileSize = NULL;
}/* if(fileSize) */
continue;
}/* if(!res) */
if(path) {
free(path);
path = NULL;
}/* if(path) */
}/* if(NULL != str) */
recv_line(sock, &filePerms);
res = changeMod(fileName, filePerms);
printf("filePerms = %s\n", filePerms);
if(!res) {
printf("error while changing mode of file %s\n",
fileName);
exitFlag = 1;
if(fileName) {
free(fileName);
fileName = NULL;
}/* if(fileName) */
if(filePerms) {
free(filePerms);
filePerms = NULL;
}/* if(filePerms) */
if(fileSize) {
free(fileSize);
fileSize = NULL;
}/* if(fileSize) */
continue;
}/* if(res != 0) */
recv_line(sock, &fileSize);
printf("fileSize = %s\n", fileSize);
fSize = atoi(fileSize);
printf("fSize = %d\n", fSize);
res = getFileContents(sock, fileName, fSize);
if(!res) {
printf("error while recieving contents of file %s\n",
fileName);
exitFlag = 1;
if(fileName) {
free(fileName);
fileName = NULL;
}/* if(fileName) */
if(filePerms) {
free(filePerms);
filePerms = NULL;
}/* if(filePerms) */
if(fileSize) {
free(fileSize);
fileSize = NULL;
}/* if(fileSize) */
continue;
}/* if(res != 0) */
if(fileName) {
free(fileName);
fileName = NULL;
}/* if(fileName) */
if(filePerms) {
free(filePerms);
filePerms = NULL;
}/* if(filePerms) */
if(fileSize) {
free(fileSize);
fileSize = NULL;
}/* if(fileSize) */
}/* while(1) */
if(exitFlag) {
return 0;
}/* if(exitFlag) */
return 1;
}/* getDirContents() */
int main(int argc, char *argv[])
{
int s,t;
char tpbuf[16];
char *dirName;
int res;
if((s = openlistener(PORT)) == (int) NULL) {
exit(0);
}/* if((s = openlistener(PORT)) == (int) NULL) */
while(1) {
if(pollsocket(s, 10000)) {
t = acceptfromlistener(s, tpbuf);
printf("Connection from %s\n", tpbuf);
recv_line(t, &dirName);
printf("dirName = %s\n", dirName);
res = getDirContents(t, CVS_BASE_PATH, dirName);
if(!res) {
printf("unable to get contents of dir %s\n",
dirName);
}/* if(!res) */
if(dirName) {
free(dirName);
dirName = NULL;
}/* if(dirName) */
closesock(t);
}/* if(pollsocket(s, 10000)) */
}/* while(1) */
}/* main() */
/************************ server.c
*******************************/
_______________________________________________
This is the Linux C Programming List
: http://lists.linux.org.au/listinfo/linuxcprogramming List
More information about the linuxCprogramming
mailing list