[LCP]moving folder contents from one m/c to another
Andrew Weaver
Andrew.Weaver at tecnomen.fi
Tue Dec 17 16:00:01 UTC 2002
On Tuesday, December 17, 2002 9:33 AM, mehul radheshyam choube
[SMTP:mrc_cprog at rediffmail.com] wrote:
> 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.
What does not work about it?
> 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.
>
These are probably not good delimiter choices since you will never know if a
file contains LFs. Think more about your protocol. Get something that tells
the reading side how long the message is for instance. Also, you should
probably have a "message type" so send msg type 1 contains ascii filename
and permissions, msg type 2 is the file in chunks of XXX bytes msg type 3 is
end of file.
> 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