一个简单的IPmsg程序源码分析（二）

　　离上篇一个简单的IPmsg程序源码分析（一）已经基本半个月（上篇最初发布在点点上面，后边纠结了一下还是选择了博客园），利用空闲的时间终于把源码的构架和一些细节基本都搞清楚了，总的来说是很简单的一个客户端。所以就只用这一篇文章全部说明吧。

　　整个程序的核心是几个全局变量：

 1 typedef struct filenode filenode;
 2 
 3 typedef struct command
 4 {
 5   unsigned int version;
 6   unsigned int packetNo;
 7   char         senderName[NAMELEN];
 8   char         senderHost[NAMELEN];
 9   unsigned int commandNo;
10   char         additional[MSGLEN];
11   struct sockaddr_in peer;
12   filenode *   fileList;
13   struct command *next;
14 }command;
15 
16 struct filenode //文件序号:文件名:大小(单位:字节):最后修改时间:文件属性 [: 附加属性=val1[,val2…][:附加信息=…]]:\a文件序号…
17 {
18   int    tcpSock;
19   unsigned int    fileNo;
20   char   fileName[FILENAME];
21   char   fileSize[NAMELEN];
22   char   mtime[NAMELEN];
23   int    fileType;
24   char   otherAttrs[2*NAMELEN];
25   struct filenode* next;
26 };
27 
28 typedef struct gsNode
29 {
30   int tcpSock;
31   struct sockaddr_in peer;
32   unsigned int packetNo;
33   int     transferring;
34   int    cancelled;
35   char  *targetDir;
36   filenode fileList;
37   struct gsNode *next;
38 } gsNode;
39 
40 typedef struct msgList
41 {
42   command comHead;
43   command *comTail;
44 } msgList;
45 
46 
47 extern const char allHosts[]; //广播用地址
48 extern int msgSock; //消息
49 extern int tcpSock; //文件
50 extern struct passwd* pwd; 
51 extern struct utsname sysName;
52 extern char workDir[FILENAME];
53 extern int utf8; //系统的LC_CTYPE
54 
55 extern gsNode sendFHead, getFHead; //发送和接收文件列表
56 extern msgList mList; //接受到的消息列表
57 
58 extern pthread_mutex_t sendFMutex; //发送文件
59 extern pthread_mutex_t getFMutex;  //接收文件
60 extern pthread_mutex_t msgMutex;   //消息队列
61 extern pthread_mutex_t usrMutex;   //消息队列
62 extern sem_t waitNonEmpty, waitNonFull; //消息列表信号量

　　最核心是下面这3个全局结构体变量，程序几个线程都基本都是在读取和写入这3个结构体：

1 extern gsNode sendFHead, getFHead; //发送和接收文件列表
2 extern msgList mList; //接受到的消息列表

　　程序运行是有4个主要线程：

1 pthread_create(&procer, NULL, &processor, NULL); 
2   pthread_create(&recver, NULL, &receiver, &msgSock);
3   pthread_create(&iter, NULL, &interacter, NULL);
4   pthread_create(&cler, NULL, &cleaner, NULL);

　　processor循环从mList中读取收到的消息，解析消息，并根据协议规定方式处理，如果是发送带有附件文件，则在getFHead中加入待接受文件的节点信息。

　　receiver负责循环从msgSock套接字接受消息，然后把消息存入mList消息列表中。

　　interacter线程是提供和用户的交互，供用户选择自己需要的操作，包裹：查看在线的主机、给在线的主机发送消息、发送文件，接受文件等（自动接受消息，在processor中会把接受到的消息和发消息的主机名直接输出到终端）。

　　cleaner线程是清理sendFHead和getFHead中已经发送/接受完成的节点，释放内存空间，没半分钟执行一次。

　　消息的接收和发送：

　　接收：线程receiver循环从msgSock套接字接收并写入mList列表中，线程processor处理mList，把消息输出在终端上面。

　　发送：线程interacter一直阻塞在fgets函数上面，等待用户的输入，当用户输入：talk或者tk（大小写无所谓，程序会自动把输入转换为小写）的时候，调用listUsers函数列出当前在线的主机，然后输入要发送消息的主机号，回车就是显示输入提示符：输入消息并回车就可以把消息发送给对方。

　　文件（文件夹）的发送和接收：

　　发送：感觉作者的文件发送方式很有意思（不过也可能是我读的代码少的原因），用户输入sf（sendfile）后，提示用户输入要发送的文件（夹），输入文件路径，确定，就会把文件发送给对方。在main函数中有下面一段代码：

 1 while(1)
 2   {
 3     if ((tmp=accept(tcpSock, NULL, NULL))<0)
 4       printf("Tcp accept error.\n");
 5     else
 6     {
 7       fSock = (int *)malloc(sizeof(int));
 8       *fSock = tmp;
 9       pthread_create(&fler, &attr, &sendData, fSock);
10     }
11     
12   }

　　循环accept全局的tcpSock套接字，然后启动发送数据线程。发送进程从sendFHead列表中读取存放有需要发送的文件信息的节点。上边说的用户输入文件名字后是把信息写入到sendFHead里面就返回了。这样实现的好处是简单，不用考虑麻烦的通信还有线程同步问题。不过感觉这样扩展性不好（个人感觉）。还有一个ceaseSend（cs）命令用于取消传输，就是查看还没有传输成功的文件，shutdown相应传输线程的套接字。

　　接收：processor读取到一条设置了 IPMSG_FILEATTACHOPT标志位的 IPMSG_SENDMSG命令时，说明对方发送了文件，文件信息在这条命令的附件部分，processor线程就把命令信息输出到终端，同时把待接受的文件信息写入getFHead列表中。用户要接受文件，就输入gf(getfile)，interacter线程就调用recvfiles函数，此函数读取getFHead列表中待接收的文件信息并输出到界面，让用户选择需要接收的文件。然后创建getData线程接受文件（夹）（接收线程用的TCP套接字在getData线程里面创建）。作者没有实现拒绝接收选项，你不管的话（不 getfile）文件一直在那里等待接收，除非对方主动取消传输。

　　　　以上就是这个程序的所有功能和实现方式，后边会陆续附上程序中主要函数代码及其详细的注释。

代码及其注释（收发文件夹的部分没有分析注释，感觉作者实现的实在麻烦）：

main

  1 /**********************************************************
  2  *Filename: main.c
  3  *Author:   星云鹏
  4  *Date:     2008-05-15
  5  *
  6  *主程序、各个线程
  7  *********************************************************/
  8 
  9 
 10 #include "users.h"
 11 #include "ipmsg.h"
 12 #include "send_receive.h"
 13 #include "coms.h"
 14 #include <langinfo.h>
 15 #include <locale.h>
 16 #include <pthread.h>
 17 
 18 extern void destroyer();
 19 
 20 //用户输入
 21 void* interacter(void* option)
 22 {
 23   char com[20], *fileName;
 24   int count;
 25 
 26   while(1)
 27   {
 28     printf("\n(ipmsg):");
 29     fgets(com, sizeof(com), stdin);
 30 
 31     transfStr(com, 1); //去掉开头结尾空白字符，变成全小写
 32 
 33     if (!strcmp(com, "list") ||
 34         !strcmp(com, "ls"))
 35     {
 36       pthread_mutex_lock(&usrMutex);
 37       count = listUsers(NULL, &userList, 2, 1);//只是列出在线的主机列表
 38       pthread_mutex_unlock(&usrMutex);
 39     }
 40     else if (!strcmp(com, "quit") ||
 41              !strcmp(com, "q"))
 42     {
 43       logout(); //下线，向广播地址发送IPMSG_BR_EXIT
 44       destroyer(); //清理数据
 45       exit(0);
 46     }
 47     else if (!strcmp(com, "refresh") ||
 48              !strcmp(com, "rf"))
 49     {
 50       login();//登录
 51       pthread_mutex_lock(&usrMutex);
 52       count = listUsers(NULL, &userList, 2, 1);//只是列出
 53       pthread_mutex_unlock(&usrMutex);
 54     }
 55     else if (!strcmp(com, "talk") ||
 56              !strcmp(com, "tk"))
 57     {
 58       saySth();    //向在线主机发送消息
 59     }
 60     else if (!strcmp(com, "sendfile") ||
 61              !strcmp(com, "sf"))
 62     {
 63       selectFiles();    //选择要发送的文件（夹）
 64     }
 65     else if (!strcmp(com, "getfile") ||
 66              !strcmp(com, "gf"))
 67     {
 68       recvFiles();    //接收文件（夹）
 69     }
 70     else if (!strcmp(com, "ceaseSend") ||
 71              !strcmp(com, "cs"))
 72     {
 73       ceaseSend();    //取消发送文件
 74     }
 75     else if (!strcmp(com, "help") ||
 76              !strcmp(com, "h"))
 77       printf(IMHELP);    //输出帮助信息
 78   }
 79 
 80 }
 81 
 82 //接收udp包
 83 void* receiver(void *option)
 84 {
 85   command *peercom;
 86   struct sockaddr_in peer;
 87   int mSock = *(int*)option, len;
 88   char buf[COMLEN];
 89   
 90   //从msgSock循环接收消息
 91   while(1)
 92   {
 93     if (recvfrom(mSock, buf, sizeof(buf), 0, (struct sockaddr*)&peer, &len)<0)    //接收
 94       continue;
 95     peercom = (command*)malloc(sizeof(command));
 96     bzero(peercom, sizeof(command));
 97     msgParser(buf, sizeof(buf), peercom);    //解析接收到的消息
 98     memcpy(&peercom->peer, &peer, sizeof(peercom->peer));
 99 
100     sem_wait(&waitNonFull);
101     pthread_mutex_lock(&msgMutex);
102 
103     //把解析好的命令加入mList列表
104     mList.comTail->next = peercom;
105     mList.comTail = peercom;
106 
107     sem_post(&waitNonEmpty); 
108     pthread_mutex_unlock(&msgMutex);
109   }
110 }
111 
112 //处理接收的udp包
113 void* processor(void *option)
114 {
115   command *peercom, com;
116   int comMode, comOpt, temp;
117   int len;
118   user *cur;
119   filenode *head, *curFile;
120   gsNode *preSend, *curSend, *curGet, *preGet;
121 
122   initCommand(&com, IPMSG_NOOPERATION);
123   while(1)
124   {
125     sem_wait(&waitNonEmpty);
126     pthread_mutex_lock(&msgMutex);
127    
128     //从mList列表中读取待处理的信息
129     peercom = mList.comHead.next;
130     mList.comHead.next = mList.comHead.next->next;
131     if (mList.comHead.next == NULL)
132       mList.comTail = &mList.comHead;
133     
134     sem_post(&waitNonFull); 
135     pthread_mutex_unlock(&msgMutex);
136     
137     memcpy(&com.peer, &peercom->peer, sizeof(com.peer));
138     
139     //得到信息中的命令模式和标识（协议规定，见ipmsg.h）
140     comMode = GET_MODE(peercom->commandNo);
141     comOpt = GET_OPT(peercom->commandNo);
142 
143     //如果设置了IPMSG_SENDCHECKOPT，就是给发送方发送回去确认收到信息
144     if (comOpt & IPMSG_SENDCHECKOPT)
145     {
146       com.packetNo = (unsigned int)time(NULL);
147       snprintf(com.additional, MSGLEN, "%d", peercom->packetNo);
148       com.commandNo = IPMSG_RECVMSG;
149       sendMsg(&com); //发送回应
150     }
151    
152 
153     //解析命令
154     switch (comMode)
155     {
156     case IPMSG_SENDMSG: //发送命令
157     
158         //如果命令包的扩展部分（消息内容在这个部分）不为空，输出消息发送方的名字和主机名，然后输出消息
159       if (strlen(peercom->additional)>0)
160       {
161         printf("\nGet message from: %s(%s)\n", peercom->senderName, peercom->senderHost);
162         puts(peercom->additional);
163       }
164 
165       //如果命令里面设置了IPMSG_FILEATTACHOPT（表示有发送文件请求）
166       if (comOpt & IPMSG_FILEATTACHOPT)
167       {
168         printf("\nGet Files from: %s(%s).\nInput \"getfile(gf)\" to download.\n",
169                peercom->senderName, peercom->senderHost);
170         //建立接收文件信息的新节点
171         curGet = (gsNode*)malloc(sizeof(gsNode));
172         initGsNode(curGet);
173         //把命令中所含信息填入节点
174         memcpy(&curGet->peer, &peercom->peer, sizeof(curGet->peer));
175         curGet->packetNo = peercom->packetNo;
176         curGet->fileList.next = peercom->fileList;
177         peercom->fileList = NULL; //
178         
179         //把新节点加入getFHead列表中
180         preGet = &getFHead;
181         pthread_mutex_lock(&getFMutex);
182         while ((preGet->next!=NULL) &&
183                (preGet->next->packetNo!=curGet->packetNo))
184           preGet = preGet->next;
185         
186         if (preGet->next==NULL)
187           preGet->next = curGet;
188         
189         pthread_mutex_unlock(&getFMutex);
190       }
191       
192       break;
193       
194       //通知新上线命令，把用户信息建立一个新节点加入userList列表里
195     case IPMSG_ANSENTRY: //
196       cur = (user*)malloc(sizeof(user));
197       memcpy(&cur->peer, &peercom->peer, sizeof(cur->peer));
198       strncpy(cur->name, peercom->senderName, NAMELEN);
199       strncpy(cur->host, peercom->senderHost, NAMELEN);
200       strncpy(cur->nickname, peercom->additional, NAMELEN);
201       cur->inUse = 0;
202       cur->exit = 0;
203       cur->next = NULL;
204       pthread_mutex_lock(&usrMutex); //lock
205       if (insertUser(&userList, cur)<0)
206         free(cur);
207       pthread_mutex_unlock(&usrMutex); //unlock
208       break;
209     case IPMSG_BR_ENTRY://处理同IPMSG_ANSENTRY，这个是第一次上线，要发送回应，即向对方发送IPMSG_ANSENTRY
210       com.packetNo = (unsigned int)time(NULL);
211       com.commandNo = IPMSG_ANSENTRY;//
212       strncpy(com.additional, pwd->pw_name, MSGLEN);
213       sendMsg(&com);
214 
215       cur = (user*)malloc(sizeof(user));
216       memcpy(&cur->peer, &peercom->peer, sizeof(cur->peer));
217       strncpy(cur->name, peercom->senderName, NAMELEN);
218       strncpy(cur->host, peercom->senderHost, NAMELEN);
219       strncpy(cur->nickname, peercom->additional, NAMELEN);
220       cur->inUse = 0;
221       cur->exit = 0;
222       cur->next = NULL;
223       pthread_mutex_lock(&usrMutex);
224       if (insertUser(&userList, cur)<0)
225         free(cur);
226       pthread_mutex_unlock(&usrMutex);
227       break;
228     case IPMSG_RECVMSG:
229       //
230       break;
231     case IPMSG_RELEASEFILES: //应该验证一下peer
232     //取消发送文件请求（在发送列表中找到节点，shutdown它的TCP套接字）
233       preSend = &sendFHead;
234       pthread_mutex_lock(&sendFMutex);
235       curSend = sendFHead.next;
236       while ((curSend!=NULL)&&(curSend->packetNo!=atoi(peercom->additional)))
237       {
238         preSend = preSend->next;
239         curSend = curSend->next;
240       }
241       
242       if (curSend!=NULL)
243       {
244         curSend->cancelled = 1;
245         if (curSend->tcpSock>0)
246           shutdown(curSend->tcpSock, SHUT_RDWR);
247       }
248       pthread_mutex_unlock(&sendFMutex);
249       break;
250     case IPMSG_BR_EXIT://下线通知。
251       pthread_mutex_lock(&usrMutex);
252       delUser(&userList, peercom);
253       pthread_mutex_unlock(&usrMutex);
254       break;
255     case IPMSG_NOOPERATION:
256       //
257       break;
258     default:
259       printf("\nno handle, %x\n", peercom->commandNo);
260       break;
261     }
262     deCommand(peercom);
263     free(peercom);
264     peercom = NULL;
265   }
266   
267 }
268 
269 //数据清理，清理已发送完成的文件信息节点，释放内存空间
270 void destroyer()
271 {
272   gsNode *preSend, *curSend, *preGet, *curGet;
273   filenode *curFile;
274   user *curUsr, *preUsr;
275   
276   preSend = &sendFHead;
277   pthread_mutex_lock(&sendFMutex);
278   curSend = sendFHead.next;
279   while (curSend!=NULL)
280   {
281     if ((curSend->cancelled == 1) && (curSend->transferring==0))
282     {
283       preSend->next = curSend->next;
284       deGsNode(curSend);
285       free(curSend);
286     }
287     else preSend = preSend->next;
288     
289     curSend = preSend->next;
290   }
291   pthread_mutex_unlock(&sendFMutex);
292   
293   
294   preGet = &getFHead;
295   pthread_mutex_lock(&getFMutex);
296   curGet = getFHead.next;
297   while (curGet!=NULL)
298   {
299     if ((curGet->cancelled==1) &&(curGet->transferring==0))
300     {
301       preGet->next = curGet->next;
302       deGsNode(curGet);
303       free(curGet);
304     }
305     else preGet = preGet->next;
306     
307     curGet = preGet->next;
308   }
309   pthread_mutex_unlock(&getFMutex);
310 
311   preUsr = &userList;
312   pthread_mutex_lock(&usrMutex);
313   curUsr = userList.next;
314   while (curUsr!=NULL)
315   {
316     if ((curUsr->exit==1) && (curUsr->inUse==0))
317     {
318       preUsr->next = curUsr->next;
319       free(curUsr);
320     }
321     else preUsr = preUsr->next;
322     
323     curUsr = preUsr->next;
324     
325   }
326   pthread_mutex_unlock(&usrMutex);
327 }
328 
329 
330 
331 void* cleaner(void *option)
332 {
333   gsNode *preSend, *curSend, *preGet, *curGet;
334   filenode *curFile;
335   user *curUsr, *preUsr;
336   
337   while(1)
338   {
339     sleep(30); //半分钟一次
340     destroyer();
341   }
342   
343 }
344 
345 //初始化udp和tcp
346 int initSvr()
347 {
348   struct sockaddr_in server;
349   char targetHost[NAMELEN];
350   const int on=1;
351 
352   msgSock = socket(AF_INET, SOCK_DGRAM, 0);  //UDP for Msg
353   
354   tcpSock = socket(AF_INET, SOCK_STREAM, 0); //TCP for File
355   
356   server.sin_family = AF_INET;
357   server.sin_port = htons(IPMSG_DEFAULT_PORT);
358   server.sin_addr.s_addr = htonl(INADDR_ANY);
359   
360   if (setsockopt(msgSock, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on))<0)
361   {
362     printf("initSvr: Socket options set error.\n");
363     exit(1);
364   }
365 
366   if (bind(msgSock, (struct sockaddr*)&server, sizeof(server))<0)
367   {
368     printf("initSvr: Udp socket bind error.\n");
369     exit(1);
370   }
371 
372   if (bind(tcpSock, (struct sockaddr*)&server, sizeof(server))<0)
373   {
374     printf("initSvr: Tcp socket bind error.\n");
375     exit(1);
376   }
377 
378   if (listen(tcpSock, 10)<0)
379   {
380     printf("initSvr: Tcp listen error.\n");
381     exit(1);
382   }
383   
384   //printf("Commands: list(ls) talk(tk) sendfile(sf)\n"
385   //"Commands: getfile(gf) refresh(rf) ceaseSend(cs) quit(q)\n");
386   printf(IMHELP);
387 }
388 
389 int main (int argc, char *argv [])
390 {
391   pthread_t procer, recver, iter, fler, cler;
392   int *fSock;
393   int tmp;
394   pthread_attr_t attr;
395   
396   uname(&sysName);    //得到系统名
397   pwd = getpwuid(getuid());        //得到用户登录信息
398   getcwd(workDir, sizeof(workDir));        //得到用户当前工作目录
399 
400   utf8 = 0;
401   if (setlocale(LC_CTYPE, ""))
402     if (!strcmp(nl_langinfo(CODESET), "UTF-8"))        //设置系统字符集
403       utf8 = 1;
404   
405   initGsNode(&sendFHead);        //初始化文件发送队列
406   initCommand(&mList.comHead, IPMSG_NOOPERATION);        //初始化消息发送队列
407   mList.comTail = &mList.comHead;        
408   userList.next = NULL;        //初始化用户列表
409   sem_init(&waitNonEmpty, 0, 0);
410   sem_init(&waitNonFull, 0, MSGLIMIT);
411 
412   initSvr();    //初始化套接字
413   
414   //主要线程的建立
415   pthread_create(&procer, NULL, &processor, &msgSock); 
416   pthread_create(&recver, NULL, &receiver, &msgSock);
417   pthread_create(&iter, NULL, &interacter, NULL);
418   pthread_create(&cler, NULL, &cleaner, NULL);
419   login();    //登录，向广播地址发送IPMSG_BR_ENTRY命令
420 
421   //发送文件线程的建立
422   pthread_attr_init(&attr);
423   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
424   while(1)
425   {
426     if ((tmp=accept(tcpSock, NULL, NULL))<0)
427       printf("Tcp accept error.\n");
428     else
429     {
430       fSock = (int *)malloc(sizeof(int));
431       *fSock = tmp;
432       pthread_create(&fler, &attr, &sendData, fSock);
433     }
434     
435   }
436 
437   //同步线程
438   pthread_join(procer, NULL);
439   pthread_join(recver, NULL);
440   pthread_join(iter, NULL);
441   pthread_join(cler, NULL);
442   return 0;
443 }

send_receive

   1 /**********************************************************
   2  *Filename: send_receive.c
   3  *Author:   星云鹏
   4  *Date:     2008-05-15
   5  *
   6  *消息、文件（夹）的发送和接收
   7  *********************************************************/
   8 
   9 #include "send_receive.h"
  10 #include "ipmsg.h"
  11 #include "users.h"
  12 #include "coms.h"
  13 
  14 #include <sys/utsname.h>
  15 #include <string.h>
  16 #include <sys/stat.h>
  17 #include <sys/types.h>
  18 #include <dirent.h>
  19 #include <errno.h>
  20 #include <pwd.h>
  21 #include <sys/utsname.h>
  22 #include <signal.h>
  23 #include <pthread.h>
  24 
  25 
  26 //////////////////////////////////////////////////
  27 //发送udp包
  28 void* sendMsg(command* com)
  29 {
  30   char buf[COMLEN];
  31   int len, temp;
  32   
  33   msgCreater(buf, com, sizeof(buf)); //建立发送的包（包装com结构体为字符串）
  34   len = strlen(buf);
  35   if (com->commandNo & IPMSG_FILEATTACHOPT) //如果带有附件（发送文件请求）
  36       temp = strlen(buf+len+1);
  37       
  38       sendto(msgSock, buf, len+temp+2, 0,
  39              (struct sockaddr*)&com->peer, sizeof(com->peer));
  40      }
  41      //发送普通信息
  42   else sendto(msgSock, buf, len+1, 0,
  43               (struct sockaddr*)&com->peer, sizeof(com->peer));
  44 }
  45 
  46 //////////////////////////////////////////////////
  47 //聊天
  48 int saySth()
  49 {
  50   char buf[100]; //临时输入区
  51   char gMsg[MSGLEN];
  52   command com;
  53   user *cur=NULL;
  54   int remainder; //扩展区剩余空间
  55   int pos;       //扩展区的当前输入位置
  56   int who, temp, count;
  57   int sended;      //标记此包是否已经发过
  58   user *pusers[50];
  59 
  60   //列出并且选择要聊天的用户
  61   //列出并且选择要聊天的用户
  62   printf("\n*Talking mode\n"
  63          "*Continuous Enter to send msg,\n"
  64          "*Ctrl+D to quit conversation.\n");
  65   
  66   pthread_mutex_lock(&usrMutex);
  67   count = listUsers(pusers, &userList, sizeof(pusers)/sizeof(pusers[0]), 0);
  68   pthread_mutex_unlock(&usrMutex);
  69   
  70   who = inputNo(1, count, 1, "Please input user No.[1]:");
  71   
  72   if (who>0)
  73   {
  74     cur = pusers[who-1];
  75     //初始化消息命令
  76     initCommand(&com, IPMSG_SENDMSG|IPMSG_SENDCHECKOPT);
  77     memcpy(&com.peer, &cur->peer, sizeof(com.peer));
  78     
  79     remainder = MSGLEN;
  80     pos = 0;
  81     sended = 1;
  82     
  83     while(1)
  84     {
  85       printf("(talking with %s):", cur->name);
  86       if (fgets(buf, sizeof(buf), stdin)==NULL) //等待用户输入消息
  87         break;
  88       if (buf[0] != '\n')
  89       {
  90       //把消息放入发送命令的扩展区
  91         strncpy(com.additional+pos, buf, remainder);
  92         temp = strlen(com.additional+pos);
  93         pos += temp;
  94         remainder -= temp;
  95         sended = 0;
  96       }
  97 
  98       if ((buf[0]=='\n') || (remainder<=1))
  99       {
 100         if (!sended) //消息填写完成，调用sendMsg函数发送包含消息的UDP包
 101         {
 102           com.packetNo = (unsigned int)time(NULL);
 103           sendMsg(&com);
 104           sended = 1;
 105           printf("Message sent.\n");
 106         }
 107         remainder = sizeof(com.additional); //恢复扩展区大小
 108         pos = 0;
 109       }
 110       
 111     }
 112   }
 113   
 114     puts("\nEnd conversation.\n");
 115     
 116     pthread_mutex_lock(&usrMutex);
 117     unListUsers(pusers, count);
 118     pthread_mutex_unlock(&usrMutex);
 119   
 120 }
 121 
 122 /////////////////////////////////////////////////
 123 //文件发送
 124 //选择要传输的文件
 125 
 126 int selectFiles()
 127 {
 128   command com;
 129   user *cur=NULL;
 130   int  who, count, flag, fileType;
 131   unsigned int fileNo;
 132   char fileName[FILENAME];
 133   struct stat fileAttr;
 134   char *strtmp;
 135   filenode *fntmp, *head, *tail;
 136   gsNode *newTask;
 137   user *pusers[50];
 138   
 139   printf("\n*Sending mode\n"
 140          "*Continuous Enter to send file,\n"
 141          "*Ctrl+D to quit.\n"); //输出提示
 142   
 143   pthread_mutex_lock(&usrMutex);
 144   count = listUsers(pusers, &userList, sizeof(pusers)/sizeof(pusers[0]), 0); //列出用户列表
 145   pthread_mutex_unlock(&usrMutex);
 146 
 147   //选择要发送的用户，默认第一个
 148   who = inputNo(1, count, 1, "Please input user No.[1]:");
 149 
 150   if (who>0)
 151   {
 152     
 153     cur = pusers[who-1];
 154   //初始化命令，设置IPMSG_SENDMSG|IPMSG_FILEATTACHOPT用于表示有文件发送
 155     initCommand(&com, IPMSG_SENDMSG|IPMSG_FILEATTACHOPT);
 156     memcpy(&com.peer, &cur->peer, sizeof(com.peer));
 157     
 158     printf("To send file to %s(%s).\nPlease select file to send:\n", cur->name, cur->host);
 159     
 160     //建立发送文件信息节点
 161     newTask = (gsNode*)malloc(sizeof(gsNode));
 162     initGsNode(newTask);
 163     newTask->packetNo = com.packetNo;
 164     
 165     fileNo = 0;
 166     head = com.fileList;
 167     tail = com.fileList;
 168     
 169     while (1)
 170     {
 171       if (fgets(fileName, FILENAME, stdin) == NULL) //等待用户输入需要发送的文件（夹）名字。C+d取消发送
 172       {
 173         free(newTask);
 174         newTask = NULL;
 175         while (head!=NULL)
 176         {
 177           tail = head;
 178           head = head->next;
 179           free(tail);
 180         }
 181         break;
 182       }
 183 
 184        transfStr(fileName, 0); //去除前后空白字符
 185        
 186       if (fileName[0]=='\0')
 187         break;
 188       
 189       //读取文件名的信息，写入struct stat结构体
 190      if (lstat(fileName, &fileAttr)<0)
 191       {
 192         printf("Get file attributes error.\n");
 193         continue;
 194       }
 195 
 196       //确定文件类型，是文件还是文件夹
 197       if (S_ISREG(fileAttr.st_mode))
 198         fileType = 1;
 199       else if (S_ISDIR(fileAttr.st_mode))
 200         fileType = 2;
 201       else
 202       {
 203         fileType = -1;
 204         printf("Unsupported file type.\n");
 205         continue;
 206       }
 207       
 208       //建立filenode（文件信息）节点
 209       if (tail == NULL)
 210         head = tail = (filenode*)malloc(sizeof(filenode));
 211       else
 212       {
 213         tail->next = (filenode*)malloc(sizeof(filenode));
 214         tail = tail->next;
 215       }
 216       
 217       //把上边得到的struct stat文件信息填入filenode
 218       tail->next = NULL;
 219       tail->fileNo = fileNo;
 220       strncpy(tail->fileName, fileName, sizeof(tail->fileName));
 221       snprintf(tail->fileSize, sizeof(tail->fileSize), "%x", fileAttr.st_size);
 222       snprintf(tail->mtime, sizeof(tail->mtime), "%x", fileAttr.st_mtime);
 223       tail->fileType = fileType;
 224 
 225       fileNo++;
 226     }
 227     
 228     if (head==NULL)
 229     {
 230       if (newTask!=NULL)
 231         free(newTask);
 232     }
 233     else 
 234     {
 235     //初始化newTask的filenode成员
 236       newTask->fileList.next = com.fileList = head;
 237       pthread_mutex_lock(&sendFMutex); //lock
 238       newTask->next = sendFHead.next; //把newTask加入sendFHead列表
 239       sendFHead.next = newTask;
 240       pthread_mutex_unlock(&sendFMutex); //unlock
 241 
 242       if (newTask->fileList.next!=NULL)
 243       {
 244         sendMsg(&com); //可以放lock外面，发送信息给对方
 245         printf("\nWaiting to transfer.\n");
 246       }
 247     }
 248   }
 249 
 250   pthread_mutex_lock(&usrMutex);
 251   unListUsers(pusers, count);
 252   pthread_mutex_unlock(&usrMutex);
 253   
 254 }
 255 
 256 //文件或文件夹发送
 257 void* sendData(void* option)
 258 {
 259   int fSock = *(int *)option;
 260   char buf[RECFRG], fileName[FILENAME];
 261   int i, commandNo, realCount, offset, curErr;
 262   unsigned int packetNo, fileNo;
 263   filenode *preFile, *curFile;
 264   gsNode *preSend, *curSend;
 265   FILE* sfile;
 266   sigset_t mask, oldmask;
 267 
 268   free(option);
 269   
 270   sigemptyset(&mask);
 271   sigaddset(&mask, SIGPIPE);
 272   if (pthread_sigmask(SIG_BLOCK, &mask, &oldmask) != 0)
 273     printf("SIG_BLOCK error.\n");
 274   
 275   //以tcp的方式接受传输请求
 276   for (i=0;i<4;i++)
 277   {
 278     if (readDelimiter(fSock, buf, RECFRG, ':')<=0)
 279     {
 280       printf("Transfer cancelled.\n");
 281       shutdown(fSock, SHUT_RDWR);
 282       return NULL;
 283     }  
 284   }
 285 
 286   if (readDelimiter(fSock, buf, RECFRG, ':')<=0)
 287   {
 288     printf("Transfer cancelled.\n");
 289     shutdown(fSock, SHUT_RDWR);
 290     return NULL;
 291   }
 292   
 293   commandNo = atoi(buf);
 294 
 295   if (!(commandNo & IPMSG_GETFILEDATA))
 296   {
 297     printf("Invalid request.\n");
 298     shutdown(fSock, SHUT_RDWR);
 299     return NULL;
 300   }
 301   
 302   
 303   if (readDelimiter(fSock, buf, RECFRG, ':')<=0)
 304   {
 305     printf("Transfer cancelled.\n");
 306     shutdown(fSock, SHUT_RDWR);
 307     return NULL;
 308   }
 309   
 310   sscanf(buf, "%x", &packetNo);
 311 
 312   if (readDelimiter(fSock, buf, RECFRG, ':')<0)
 313   {
 314     printf("Transfer cancelled.\n");
 315     shutdown(fSock, SHUT_RDWR);
 316     return NULL;
 317   }
 318   sscanf(buf, "%x", &fileNo);
 319 
 320   pthread_mutex_lock(&sendFMutex);
 321   
 322   preSend = &sendFHead;
 323   curSend = sendFHead.next;
 324 
 325   while ((curSend != NULL) &&
 326          (curSend->packetNo!=packetNo || curSend->transferring==1 ||
 327          curSend->cancelled==1)){
 328     preSend = preSend->next;
 329     curSend = curSend->next;
 330   }
 331   
 332   if (curSend != NULL)
 333   {
 334     curSend->transferring = 1;
 335     curSend->tcpSock = fSock;
 336     pthread_mutex_unlock(&sendFMutex);
 337     
 338     curFile = curSend->fileList.next;
 339     preFile = &curSend->fileList;
 340     while ((curFile!=NULL) && (curFile->fileNo!=fileNo))
 341     {
 342       preFile = preFile->next;
 343       curFile = curFile->next;
 344     }
 345     
 346     if (curFile != NULL)
 347     {
 348       getFileName(fileName, curFile->fileName, sizeof(fileName));
 349       printf("\nStart transferring %s.\n", fileName);
 350       switch (curFile->fileType)
 351       {
 352       case 1: //发送文件
 353         if (readDelimiter(fSock, buf, RECFRG, ':')<=0) //offset似乎没用上
 354         {
 355           printf("Transfer cancelled.\n");
 356           shutdown(fSock, SHUT_RDWR);
 357           return NULL;
 358         }
 359         sscanf(buf, "%x", &offset);
 360         
 361         sfile = fopen(curFile->fileName, "r");
 362         
 363         while ((realCount = fread(buf, 1, RECFRG, sfile))>0)
 364           if (writen(fSock, buf, realCount)<0)
 365           {
 366             curErr = errno;
 367             break;
 368           }
 369         break;
 370       case 2: //发送文件夹
 371         curErr = traverseDir(fSock, curFile->fileName, sendDir); 
 372         break;
 373       default:
 374         break;
 375       }
 376     }
 377   }
 378   else pthread_mutex_unlock(&sendFMutex);
 379 
 380   pthread_mutex_lock(&sendFMutex);
 381   if ((curSend!=NULL) && (curSend->cancelled==1))
 382   {
 383     preSend->next = curSend->next;
 384     deGsNode(curSend);
 385     free(curSend);
 386     pthread_mutex_unlock(&sendFMutex);
 387     shutdown(fSock, SHUT_RDWR);
 388     printf("Transfer canceled.\n");
 389     return NULL;
 390   }
 391   
 392   if ((curErr<0) || (errno == ECONNRESET) || (errno == EPIPE)) //error or connection reset by peer
 393   {
 394     if (curFile!=NULL)
 395     {
 396       curSend->transferring = 0;
 397       curSend->tcpSock = -1;
 398     }
 399     pthread_mutex_unlock(&sendFMutex);
 400     shutdown(fSock, SHUT_RDWR);
 401     printf("Peer needs retransfer.\n");
 402     return NULL;
 403   }
 404   
 405   if (curFile!=NULL)
 406   {
 407     printf("\n%s is transferred.\n", fileName);
 408     preFile->next = curFile->next;
 409     free(curFile);
 410   }
 411   
 412   
 413   if (curSend!=NULL && curSend->fileList.next == NULL)
 414   {
 415     preSend->next = curSend->next;
 416     deGsNode(curSend);
 417     free(curSend);
 418   }
 419   else if (curSend!=NULL)
 420   {
 421     curSend->transferring = 0;
 422     curSend->tcpSock = -1;
 423   }
 424   pthread_mutex_unlock(&sendFMutex);
 425   
 426   shutdown(fSock, SHUT_RDWR);
 427 }
 428 
 429 //发送文件夹
 430 
 431 int sendDir(int fSock, const char* fullpath, int fileSize, int fileType)
 432 {
 433   char strtmp[FILENAME], strformat[50], strdata[RECFRG], fileName[FILENAME];
 434   int tmp, headLen, packetNo;
 435   FILE *sf;
 436 
 437   if (getFileName(strtmp, fullpath, sizeof(strtmp)) < 0)
 438   {
 439     printf("\nFilename is too long.\n");
 440     return -1;
 441   }
 442 
 443   addColon(strtmp, sizeof(strtmp));
 444   if (utf8)
 445     u2g(strtmp, sizeof(strtmp),
 446         fileName, sizeof(fileName));
 447   else strncpy(fileName, strtmp, sizeof(fileName));
 448   
 449   headLen = (strlen(fileName)+1) + (HL_HEADERSIZE+1) +
 450     (HL_FILETYPE+1) + (HL_FILESIZE+1) + 2*(HL_1416+1);
 451   packetNo = (unsigned int)time(NULL); //简化了，属性值并不准确
 452   snprintf(strformat, sizeof(strformat), "%%0%dx:%%s:%%0%dx:%%0%dx:14=%%0%dx:16=%%0%dx:",
 453            HL_HEADERSIZE, HL_FILESIZE, HL_FILETYPE, HL_1416-3, HL_1416-3);
 454   
 455   tmp = snprintf(strdata, sizeof(strdata), strformat,
 456            headLen, fileName, fileSize, fileType, packetNo, packetNo);
 457   
 458   switch (fileType)
 459   {
 460   case 1:
 461     if ((sf = fopen(fullpath, "r")) == NULL)
 462     {
 463       printf("file open error.\n");
 464       return -1;
 465     }
 466     if (writen(fSock, strdata, tmp)<0)
 467       return -1;
 468     while ((tmp = fread(strdata, 1, RECFRG, sf))>0)
 469     {
 470       if (writen(fSock, strdata, tmp)<0)
 471         return -1;
 472     }
 473     fclose(sf);
 474     break;
 475   case 2:
 476    
 477     //break;
 478   case 3:
 479     if (writen(fSock, strdata, tmp)<0)
 480       return -1;
 481     break;
 482   default:
 483     break;
 484   }
 485   return 0;
 486 }
 487 
 488 //遍历要发送的文件夹，利用上面的回掉函数发送
 489 int traverseDir(int fSock, char* fullpath, Mysnd snd) //FILENAME指定了fullpath的容量
 490 {
 491   struct stat fst;
 492   struct dirent *dirp;
 493   char *ptr;
 494   DIR  *dp;
 495   int tmp;
 496   
 497 
 498   if (lstat(fullpath, &fst)<0)
 499   {
 500     printf("\nDir: get attributes error.\n");
 501     return -1;
 502   }
 503   
 504   if (S_ISREG(fst.st_mode))
 505     return snd(fSock, fullpath, fst.st_size, 1);
 506   else if (S_ISDIR(fst.st_mode))
 507   {
 508     if (snd(fSock, fullpath, 0, 2)<0)
 509       return -1;
 510   }
 511   else return -1;
 512 
 513   tmp = strlen(fullpath);
 514   ptr = fullpath + tmp;
 515   
 516   *ptr++ = '/'; //tmp+1
 517   *ptr = '\0';
 518 
 519   if ((dp=opendir(fullpath)) == NULL)
 520   {
 521     printf("\nDir: open error.\n");
 522     return -1;
 523   }
 524 
 525   while ((dirp=readdir(dp)) != NULL)
 526   {
 527     if (strcmp(dirp->d_name, ".")==0 ||
 528         strcmp(dirp->d_name, "..")==0)
 529       continue;
 530 
 531     strncpy(ptr, dirp->d_name, FILENAME-tmp-1);
 532     if (traverseDir(fSock, fullpath, snd)<0)
 533       return -1;
 534   }
 535 
 536   ptr[-1] = '\0'; //还原fullname
 537   snd(fSock, ".", 0, 3);
 538   if (closedir(dp) < 0)
 539   {
 540     printf("\nDir: close error.\n");
 541     return -1;
 542   }
 543   return 0;
 544 }
 545 
 546 //列举待发送文件
 547 int listSFiles(gsNode **list, gsNode *gs, int size)
 548 {
 549   filenode *curFile;
 550   int tmp=0;
 551 
 552   while ((gs!=NULL)&&(tmp<size))
 553   {
 554     if ((gs->cancelled==0))
 555     {
 556       *list++ = gs;
 557       tmp++;
 558     }
 559     gs = gs->next;
 560   }
 561   
 562   return tmp;
 563   
 564 }
 565 
 566 //取消文件传输
 567 int ceaseSend()
 568 {
 569   gsNode *gsList[CAPACITY], *cur;
 570   int tmp, index, count;
 571   char buf[FILENAME];
 572   filenode *curFile;
 573 
 574   while(1)
 575   {
 576     pthread_mutex_lock(&sendFMutex);
 577     count = listSFiles(gsList, sendFHead.next, sizeof(gsList)/sizeof(gsList[0])-1);
 578     pthread_mutex_unlock(&sendFMutex);
 579     
 580     if (count == 0)
 581       return 0;
 582     else
 583     {
 584       printf("\n++++++++++++++++++++\n");
 585       printf("Files to send:\n");
 586       for(tmp=1;tmp<=count;tmp++)
 587       {
 588         printf("%d. ", tmp);
 589         curFile = (*(gsList+tmp-1))->fileList.next;
 590         while (curFile!=NULL)
 591         {
 592           printf("%s ", curFile->fileName);
 593           curFile = curFile->next;
 594         }
 595         printf("\n");
 596       }
 597       printf("++++++++++++++++++++\n");
 598     }
 599 
 600     index = inputNo(1, count, 1,
 601                     "Which file(s) to cancel?(Ctrl+D to quit)\nNumber[1]:");
 602 
 603     if (index<0)
 604       return -1;
 605 
 606     pthread_mutex_lock(&sendFMutex);
 607     (*(gsList+index-1))->cancelled = 1;
 608     if ((*(gsList+index-1))->tcpSock>=0)
 609       shutdown((*(gsList+index-1))->tcpSock, SHUT_RDWR);
 610     pthread_mutex_unlock(&sendFMutex);
 611   }
 612 }
 613 
 614 
 615 ////////////////////////////////////////////////////
 616 //文件接收
 617 //选择要接收的文件
 618 int recvFiles()
 619 {
 620   gsNode *gsList[CAPACITY], *cur;
 621   int tmp, index, count;
 622   char buf[FILENAME];
 623   struct stat dirAttr;
 624   pthread_t gFile;
 625   filenode *curFile;
 626   pthread_attr_t attr;
 627   
 628   while(1)
 629   {//访问getFHead列表，列出等待接受的文件信息
 630     pthread_mutex_lock(&getFMutex);
 631     //把待接收文件信息节点存入gsList
 632     count = listGFiles(gsList, getFHead.next, sizeof(gsList)/sizeof(gsList[0])-1);
 633     pthread_mutex_unlock(&getFMutex);
 634     
 635     if (count == 0)
 636       return -1;
 637     else
 638     {//待接受文件名和编号
 639       printf("\n++++++++++++++++++++\n");
 640       printf("Files to get:\n");
 641       for(tmp=1;tmp<=count;tmp++)
 642       {
 643         printf("%d. ", tmp);
 644         curFile = (*(gsList+tmp-1))->fileList.next;
 645         while (curFile!=NULL)
 646         {
 647           printf("%s ", curFile->fileName);
 648           curFile = curFile->next;
 649         }
 650         printf("\n");
 651       }
 652       printf("++++++++++++++++++++\n");
 653     }
 654     //选择需要接收的文件，默认第一个。
 655     index = inputNo(1, count, 1,
 656                     "Which file(s) to get?(Ctrl+D to quit)\nNumber[1]:");
 657 
 658     if (index<0)
 659       return -1;
 660     
 661     while(1)
 662     {
 663       printf("Where do you want to save?(Ctrl+D to quit)\nTarget dir[.]:");
 664       if (fgets(buf, sizeof(buf), stdin)==NULL) //输入保存路径，默认当前目录
 665         return -1;
 666 
 667       transfStr(buf, 0); //去除前后空白字符
 668       
 669       if (buf[0]=='\0')
 670       {
 671         buf[0]='.';
 672         buf[1]='\0';
 673       }
 674     //检查存储路径是否合法
 675       if ((stat(buf, &dirAttr)<0) ||
 676           !S_ISDIR(dirAttr.st_mode) ||
 677           (access(buf, W_OK)<0))
 678         printf("Invalid directory. Please input again.\n");
 679       else break;
 680     }
 681     
 682     cur = *(gsList+index-1);
 683     tmp = strlen(buf);
 684     pthread_mutex_lock(&getFMutex);
 685     if (cur->cancelled == 0)
 686     {//设置节点信息
 687       cur->targetDir = (char*)malloc(tmp+1);
 688       strncpy(cur->targetDir, buf, tmp+1);
 689       cur->transferring = 1;
 690     }
 691     //启动getData线程，开始接收文件
 692     pthread_mutex_unlock(&getFMutex);
 693     pthread_attr_init(&attr);
 694     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 695     pthread_create(&gFile, &attr, &getData, cur);
 696   }
 697 
 698 }
 699 
 700 //文件接收线程
 701 void* getData(void* option)
 702 {
 703   gsNode *gList = (gsNode *)option;
 704   filenode *head=&gList->fileList, *cur;
 705   int fileType, tmp;
 706   command com;
 707 
 708   printf("\nStart getting files.\n");
 709   while((cur=head->next) != NULL)
 710   {//查看文件类型（文件还是文件夹），用不同的函数接收
 711     fileType = cur->fileType & 0x03;
 712     switch (fileType)
 713     {
 714     case 1:
 715       tmp=getFile(cur, gList);//接收文件
 716       break;
 717     case 2:
 718       tmp=getDir(cur, gList);//接收文件夹
 719       break;
 720     default:
 721       tmp = -1;
 722       printf("\nUnsupported file type.\n%s fails to be transfered.\n", cur->fileName);
 723       break;
 724     }
 725    //接收错误（出现了套接字建立错误，链接错误，传输错误等） 
 726     if (tmp<0)
 727     {
 728       initCommand(&com, IPMSG_RELEASEFILES); //设置取消传输
 729       snprintf(com.additional, sizeof(com.additional), "%d", gList->packetNo);
 730       memcpy(&com.peer, &gList->peer, sizeof(com.peer));
 731       sendMsg(&com);
 732       pthread_mutex_lock(&getFMutex);
 733       //设置结构体成员标识参数
 734       gList->cancelled = 1;
 735       gList->transferring = 0;
 736       pthread_mutex_unlock(&getFMutex);
 737       printf("\n%s fails to be transfered.\n", cur->fileName);
 738       return NULL;
 739     }
 740     
 741     printf("\n%s is transferred.\n", cur->fileName);
 742     head->next = cur->next;
 743     free(cur);
 744   }
 745 
 746   pthread_mutex_lock(&getFMutex);
 747   gList->cancelled = 1; //其实是已经完成，成功后设置传输成功。
 748   gList->transferring = 0;
 749   pthread_mutex_unlock(&getFMutex);
 750   
 751   printf("File reception done.\n");
 752 }
 753 
 754 //接收文件
 755 int getFile(void* option, gsNode *gList)
 756 {
 757   int sockfd, readBytes;
 758   char buf[COMLEN];
 759   char recvs[RECFRG];
 760   filenode *head = (filenode*)option;
 761   command com;
 762   struct sockaddr_in peer;
 763   long fileSize, offset=0;
 764   FILE* recvFile;
 765     //初始化文件接收命令
 766   initCommand(&com, IPMSG_GETFILEDATA);  //Regular file
 767   snprintf(com.additional, MSGLEN, "%x:%x:%x", gList->packetNo, head->fileNo, offset);
 768   //建立TCP套接字
 769   sockfd = socket(AF_INET, SOCK_STREAM, 0);
 770 
 771   bzero(&peer, sizeof(peer));
 772   peer.sin_family = AF_INET;
 773   peer.sin_port = htons(IPMSG_DEFAULT_PORT);
 774   memcpy(&peer.sin_addr, &gList->peer.sin_addr, sizeof(peer.sin_addr));
 775   //连接
 776   if (connect(sockfd, (struct sockaddr*)&peer, sizeof(peer))<0)
 777   {
 778     printf("File connect error.\n");
 779     return -1;
 780   }
 781   
 782   msgCreater(buf, &com, sizeof(buf));//创建发送消息
 783 
 784   if (writen(sockfd, buf, strlen(buf)+1)<0)    //接收文件命令消息发送给对方
 785     return -1;
 786 
 787   sscanf(head->fileSize, "%x", &fileSize);
 788 
 789   if ((recvFile = fopen(head->fileName, "w+")) == NULL) //建立文件描述符
 790   {
 791     printf("getFile: file create error.\n");
 792     return -1;
 793   }
 794 
 795   while (fileSize>0)
 796   {
 797   //从套接字接收文件内容
 798     readBytes = fileSize < RECFRG ? fileSize:RECFRG;
 799     if ((readBytes = readn(sockfd, recvs, readBytes))<0) //RECFRG
 800     {
 801       printf("getFile: data transfer error.\n");
 802       return -1;
 803     }
 804     //接收到的内容写入文件描述符
 805     fwrite(recvs, 1, readBytes, recvFile);
 806     fileSize -= readBytes;
 807   }
 808   fclose(recvFile); //关闭文件描述符
 809   
 810   close(sockfd); //关闭套接字
 811   return 0;
 812 }
 813 
 814 //接收文件夹时分析，头部
 815 int parseHeader(filenode *pfn, char * recvs)
 816 {
 817   char *strhead, *strtmp, gMsg[FILENAME];
 818   int i=0;
 819   
 820   strhead = recvs;
 821   while (i<3) //分析前3段
 822   {
 823     strtmp = strchr(strhead, ':');
 824     if (strtmp == NULL)
 825       return -1;
 826     *strtmp = '\0';
 827 
 828     switch (i)
 829     {
 830     case 0:
 831       
 832       strncpy(gMsg, strhead, sizeof(gMsg));
 833       delColon(gMsg, sizeof(gMsg));
 834       if (utf8)
 835         g2u(gMsg, sizeof(gMsg),
 836             pfn->fileName, sizeof(pfn->fileName));
 837       else strncpy(pfn->fileName, gMsg, sizeof(pfn->fileName));
 838       break;
 839     case 1:
 840       //sscanf(strhead, "%x", &pfn->fileSize);
 841       strncpy(pfn->fileSize, strhead, sizeof(pfn->fileSize));
 842       break;
 843     case 2:
 844       sscanf(strhead, "%x", &pfn->fileType);
 845       break;
 846       //case 3: //进行了简化
 847       // strncpy(pfh->h14, strhead+3, sizeof(pfh->h14));
 848       //break;
 849       //case 4:
 850       //strncpy(pfh->h16, strhead+3, sizeof(pfh->h16));
 851       //break;
 852     default:
 853       break;
 854     }
 855 
 856     strhead = strtmp+1;
 857     i++;
 858   }
 859 
 860   strncpy(pfn->otherAttrs, strhead, sizeof(pfn->otherAttrs));
 861   
 862   return 0;
 863 }
 864 
 865 //接收文件夹
 866 int getDir(void *option, gsNode *gList)
 867 {
 868   int sockfd, readBytes, headerSize, fileType, dirDepth=0, tmp;
 869   char buf[COMLEN], recvs[RECFRG], hSize[HSIZE], fullPath[2*FILENAME];
 870   filenode *head = (filenode*)option, *cur, fn;
 871   command com;
 872   struct sockaddr_in peer;
 873   long  offset=0, fileSize;
 874   FILE* recvFile;
 875 
 876   strncpy(fullPath, gList->targetDir, sizeof(fullPath)); //文件路径写入fullPath
 877   
 878   initCommand(&com, IPMSG_GETDIRFILES); //Direcotry
 879   
 880   snprintf(com.additional, MSGLEN, "%x:%x:%x", gList->packetNo, head->fileNo, offset);
 881   
 882   sockfd = socket(AF_INET, SOCK_STREAM, 0);
 883 
 884   bzero(&peer, sizeof(peer));
 885   peer.sin_family = AF_INET;
 886   peer.sin_port = htons(IPMSG_DEFAULT_PORT);
 887   memcpy(&peer.sin_addr, &gList->peer.sin_addr, sizeof(peer.sin_addr));
 888   
 889   if (connect(sockfd, (struct sockaddr*)&peer, sizeof(peer))<0)
 890   {
 891     printf("File connect error.\n");
 892     return -1;
 893   }
 894 
 895   msgCreater(buf, &com, sizeof(buf));
 896   
 897   if (writen(sockfd, buf, strlen(buf)+1)<0)
 898     return -1;
 899   //以上处理同getfile
 900   do
 901   {
 902     //检验路径名是否合法
 903     tmp = strlen(fullPath);
 904     if (tmp+1>=sizeof(fullPath))
 905     {
 906       printf("getDir: target directory is too lang.\n");
 907       return -1;
 908     }
 909     if (fullPath[tmp-1]!='/')
 910     {
 911       fullPath[tmp] = '/';
 912       fullPath[tmp+1] = '\0';
 913     }
 914   
 915     readBytes = readDelimiter(sockfd, hSize, HSIZE, ':'); //读取定界符（定界符见协议），读遇到的以一个分界符之前的内容
 916     sscanf(hSize, "%x", &headerSize);//把字符串长度写入headerSize
 917     if (headerSize<=0 || headerSize<=readBytes || headerSize>RECFRG) //保护、防止溢出
 918       return -1;
 919     readn(sockfd, recvs, headerSize-readBytes);//读取
 920     recvs[headerSize-readBytes]='\0';
 921     
 922     if (parseHeader(&fn, recvs)<0) //分析接收到的内容。
 923     {
 924       printf("getDir: Parse protocol failed.\n");
 925       return -1;
 926     }
 927     
 928     switch (fn.fileType & 0x03) //分析文件类型
 929     {
 930     case IPMSG_FILE_REGULAR:
 931 
 932       strncat(fullPath, fn.fileName, sizeof(fullPath)-tmp-1);
 933       if ((recvFile = fopen(fullPath, "w+")) == NULL)
 934       {
 935         printf("Open error.\n");
 936         return -1;
 937       }
 938       
 939       sscanf(fn.fileSize, "%x", &fileSize);
 940       while (fileSize>0)
 941       {
 942         readBytes = fileSize < RECFRG ? fileSize:RECFRG;
 943         if ((readBytes = readn(sockfd, recvs, readBytes))<0) //RECFRG
 944         {
 945           printf("File read error.\n");
 946           return -1;
 947         }
 948         
 949         fwrite(recvs, 1, readBytes, recvFile);
 950         fileSize -= readBytes;
 951       }
 952       fclose(recvFile);
 953       getParentPath(fullPath, sizeof(fullPath));
 954       break;
 955       
 956     case IPMSG_FILE_DIR:
 957       strncat(fullPath, fn.fileName, sizeof(fullPath)-tmp-1);
 958       tmp = strlen(fullPath);
 959       if (tmp+1>=sizeof(fullPath))
 960       {
 961         printf("getDir: target directory is too lang.\n"
 962                "Filename(%s) has been truncated.\n", fn.fileName);
 963         fullPath[tmp-1] = '/';
 964       }
 965       else
 966       {
 967         fullPath[tmp] = '/';
 968         fullPath[tmp+1] = '\0';
 969       }
 970       
 971       if (mkdir(fullPath, S_IRUSR|S_IWUSR|S_IXUSR))
 972       {
 973         printf("getDir: mkdir failed.\n");
 974         return -1;
 975       }
 976       
 977       dirDepth++;
 978       break;
 979       
 980     case IPMSG_FILE_RETPARENT:
 981       getParentPath(fullPath, sizeof(fullPath));
 982       dirDepth--;
 983       break;
 984       
 985     default:
 986       printf("Unsupported file type.\n");
 987       break;
 988     }
 989     
 990   }while(dirDepth>0);
 991 
 992   //close(sockfd);
 993   shutdown(sockfd, SHUT_RDWR);
 994   return 0;
 995 }
 996 
 997 //列举待接收文件
 998 int listGFiles(gsNode **list, gsNode *gs, int size)
 999 {
1000   filenode *curFile;
1001   int tmp=0;
1002 
1003   while ((gs!=NULL)&&(tmp<size))
1004   {
1005     if ((gs->transferring==0)&&(gs->cancelled==0))
1006     {
1007       *list++ = gs;
1008       tmp++;
1009     }
1010     gs = gs->next;
1011   }
1012   
1013   return tmp;
1014   
1015 }
1016 
1017 
1018 /////////////////////////////////////////////////
1019 //登录（上线）
1020 int login()
1021 {
1022   command com;
1023 
1024   initCommand(&com, IPMSG_BR_ENTRY);
1025   
1026   com.peer.sin_family = AF_INET;
1027   com.peer.sin_port = htons(IPMSG_DEFAULT_PORT);
1028   
1029   if (inet_pton(AF_INET, allHosts, &com.peer.sin_addr)<0)
1030     printf("login: Ip error.\n");
1031   
1032   strncpy(com.additional, pwd->pw_name, MSGLEN);
1033   
1034   sendMsg(&com);
1035   
1036 }
1037 
1038 //退出（下线）
1039 int logout()
1040 {
1041   command com;
1042 
1043   initCommand(&com, IPMSG_BR_EXIT);
1044   
1045   com.peer.sin_family = AF_INET;
1046   com.peer.sin_port = htons(IPMSG_DEFAULT_PORT);
1047   
1048   if (inet_pton(AF_INET, allHosts, &com.peer.sin_addr)<0)
1049     printf("logout: error\n");
1050 
1051   strncpy(com.additional, pwd->pw_name, MSGLEN);
1052   
1053   sendMsg(&com);
1054   printf("Bye!\n");
1055   
1056 }

posted @ 2012-11-15 10:39 風之痕阅读(1127) 评论(0) 编辑收藏举报

刷新页面返回顶部

風之痕

不要忘了你的梦想

一个简单的IPmsg程序源码分析（二）

公告