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

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

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

typedef struct filenode filenode;

typedef struct command
{
  unsigned int version;
  unsigned int packetNo;
  char         senderName[NAMELEN];
  char         senderHost[NAMELEN];
  unsigned int commandNo;
  char         additional[MSGLEN];
  struct sockaddr_in peer;
  filenode *   fileList;
  struct command *next;
}command;

struct filenode //文件序号:文件名:大小(单位:字节):最后修改时间:文件属性 [: 附加属性=val1[,val2…][:附加信息=…]]:\a文件序号…
{
  int    tcpSock;
  unsigned int    fileNo;
  char   fileName[FILENAME];
  char   fileSize[NAMELEN];
  char   mtime[NAMELEN];
  int    fileType;
  char   otherAttrs[2*NAMELEN];
  struct filenode* next;
};

typedef struct gsNode
{
  int tcpSock;
  struct sockaddr_in peer;
  unsigned int packetNo;
  int     transferring;
  int    cancelled;
  char  *targetDir;
  filenode fileList;
  struct gsNode *next;
} gsNode;

typedef struct msgList
{
  command comHead;
  command *comTail;
} msgList;


extern const char allHosts[]; //广播用地址
extern int msgSock; //消息
extern int tcpSock; //文件
extern struct passwd* pwd; 
extern struct utsname sysName;
extern char workDir[FILENAME];
extern int utf8; //系统的LC_CTYPE

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

extern pthread_mutex_t sendFMutex; //发送文件
extern pthread_mutex_t getFMutex;  //接收文件
extern pthread_mutex_t msgMutex;   //消息队列
extern pthread_mutex_t usrMutex;   //消息队列
extern sem_t waitNonEmpty, waitNonFull; //消息列表信号量

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

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

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

pthread_create(&procer, NULL, &processor, NULL); 
  pthread_create(&recver, NULL, &receiver, &msgSock);
  pthread_create(&iter, NULL, &interacter, NULL);
  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函数中有下面一段代码：

while(1)
  {
    if ((tmp=accept(tcpSock, NULL, NULL))<0)
      printf("Tcp accept error.\n");
    else
    {
      fSock = (int *)malloc(sizeof(int));
      *fSock = tmp;
      pthread_create(&fler, &attr, &sendData, fSock);
    }
    
  }

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

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

 

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

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

/**********************************************************
 *Filename: main.c
 *Author:   星云鹏
 *Date:     2008-05-15
 *
 *主程序、各个线程
 *********************************************************/


#include "users.h"
#include "ipmsg.h"
#include "send_receive.h"
#include "coms.h"
#include <langinfo.h>
#include <locale.h>
#include <pthread.h>

extern void destroyer();

//用户输入
void* interacter(void* option)
{
  char com[20], *fileName;
  int count;

  while(1)
  {
    printf("\n(ipmsg):");
    fgets(com, sizeof(com), stdin);

    transfStr(com, 1); //去掉开头结尾空白字符，变成全小写

    if (!strcmp(com, "list") ||
        !strcmp(com, "ls"))
    {
      pthread_mutex_lock(&usrMutex);
      count = listUsers(NULL, &userList, 2, 1);//只是列出在线的主机列表
      pthread_mutex_unlock(&usrMutex);
    }
    else if (!strcmp(com, "quit") ||
             !strcmp(com, "q"))
    {
      logout(); //下线，向广播地址发送IPMSG_BR_EXIT
      destroyer(); //清理数据
      exit(0);
    }
    else if (!strcmp(com, "refresh") ||
             !strcmp(com, "rf"))
    {
      login();//登录
      pthread_mutex_lock(&usrMutex);
      count = listUsers(NULL, &userList, 2, 1);//只是列出
      pthread_mutex_unlock(&usrMutex);
    }
    else if (!strcmp(com, "talk") ||
             !strcmp(com, "tk"))
    {
      saySth();    //向在线主机发送消息
    }
    else if (!strcmp(com, "sendfile") ||
             !strcmp(com, "sf"))
    {
      selectFiles();    //选择要发送的文件（夹）
    }
    else if (!strcmp(com, "getfile") ||
             !strcmp(com, "gf"))
    {
      recvFiles();    //接收文件（夹）
    }
    else if (!strcmp(com, "ceaseSend") ||
             !strcmp(com, "cs"))
    {
      ceaseSend();    //取消发送文件
    }
    else if (!strcmp(com, "help") ||
             !strcmp(com, "h"))
      printf(IMHELP);    //输出帮助信息
  }

}

//接收udp包
void* receiver(void *option)
{
  command *peercom;
  struct sockaddr_in peer;
  int mSock = *(int*)option, len;
  char buf[COMLEN];
  
  //从msgSock循环接收消息
  while(1)
  {
    if (recvfrom(mSock, buf, sizeof(buf), 0, (struct sockaddr*)&peer, &len)<0)    //接收
      continue;
    peercom = (command*)malloc(sizeof(command));
    bzero(peercom, sizeof(command));
    msgParser(buf, sizeof(buf), peercom);    //解析接收到的消息
    memcpy(&peercom->peer, &peer, sizeof(peercom->peer));

    sem_wait(&waitNonFull);
    pthread_mutex_lock(&msgMutex);

    //把解析好的命令加入mList列表
    mList.comTail->next = peercom;
    mList.comTail = peercom;

    sem_post(&waitNonEmpty); 
    pthread_mutex_unlock(&msgMutex);
  }
}

//处理接收的udp包
void* processor(void *option)
{
  command *peercom, com;
  int comMode, comOpt, temp;
  int len;
  user *cur;
  filenode *head, *curFile;
  gsNode *preSend, *curSend, *curGet, *preGet;

  initCommand(&com, IPMSG_NOOPERATION);
  while(1)
  {
    sem_wait(&waitNonEmpty);
    pthread_mutex_lock(&msgMutex);
   
    //从mList列表中读取待处理的信息
    peercom = mList.comHead.next;
    mList.comHead.next = mList.comHead.next->next;
    if (mList.comHead.next == NULL)
      mList.comTail = &mList.comHead;
    
    sem_post(&waitNonFull); 
    pthread_mutex_unlock(&msgMutex);
    
    memcpy(&com.peer, &peercom->peer, sizeof(com.peer));
    
    //得到信息中的命令模式和标识（协议规定，见ipmsg.h）
    comMode = GET_MODE(peercom->commandNo);
    comOpt = GET_OPT(peercom->commandNo);

    //如果设置了IPMSG_SENDCHECKOPT，就是给发送方发送回去确认收到信息
    if (comOpt & IPMSG_SENDCHECKOPT)
    {
      com.packetNo = (unsigned int)time(NULL);
      snprintf(com.additional, MSGLEN, "%d", peercom->packetNo);
      com.commandNo = IPMSG_RECVMSG;
      sendMsg(&com); //发送回应
    }
   

    //解析命令
    switch (comMode)
    {
    case IPMSG_SENDMSG: //发送命令
    
        //如果命令包的扩展部分（消息内容在这个部分）不为空，输出消息发送方的名字和主机名，然后输出消息
      if (strlen(peercom->additional)>0)
      {
        printf("\nGet message from: %s(%s)\n", peercom->senderName, peercom->senderHost);
        puts(peercom->additional);
      }

      //如果命令里面设置了IPMSG_FILEATTACHOPT（表示有发送文件请求）
      if (comOpt & IPMSG_FILEATTACHOPT)
      {
        printf("\nGet Files from: %s(%s).\nInput \"getfile(gf)\" to download.\n",
               peercom->senderName, peercom->senderHost);
        //建立接收文件信息的新节点
        curGet = (gsNode*)malloc(sizeof(gsNode));
        initGsNode(curGet);
        //把命令中所含信息填入节点
        memcpy(&curGet->peer, &peercom->peer, sizeof(curGet->peer));
        curGet->packetNo = peercom->packetNo;
        curGet->fileList.next = peercom->fileList;
        peercom->fileList = NULL; //
        
        //把新节点加入getFHead列表中
        preGet = &getFHead;
        pthread_mutex_lock(&getFMutex);
        while ((preGet->next!=NULL) &&
               (preGet->next->packetNo!=curGet->packetNo))
          preGet = preGet->next;
        
        if (preGet->next==NULL)
          preGet->next = curGet;
        
        pthread_mutex_unlock(&getFMutex);
      }
      
      break;
      
      //通知新上线命令，把用户信息建立一个新节点加入userList列表里
    case IPMSG_ANSENTRY: //
      cur = (user*)malloc(sizeof(user));
      memcpy(&cur->peer, &peercom->peer, sizeof(cur->peer));
      strncpy(cur->name, peercom->senderName, NAMELEN);
      strncpy(cur->host, peercom->senderHost, NAMELEN);
      strncpy(cur->nickname, peercom->additional, NAMELEN);
      cur->inUse = 0;
      cur->exit = 0;
      cur->next = NULL;
      pthread_mutex_lock(&usrMutex); //lock
      if (insertUser(&userList, cur)<0)
        free(cur);
      pthread_mutex_unlock(&usrMutex); //unlock
      break;
    case IPMSG_BR_ENTRY://处理同IPMSG_ANSENTRY，这个是第一次上线，要发送回应，即向对方发送IPMSG_ANSENTRY
      com.packetNo = (unsigned int)time(NULL);
      com.commandNo = IPMSG_ANSENTRY;//
      strncpy(com.additional, pwd->pw_name, MSGLEN);
      sendMsg(&com);

      cur = (user*)malloc(sizeof(user));
      memcpy(&cur->peer, &peercom->peer, sizeof(cur->peer));
      strncpy(cur->name, peercom->senderName, NAMELEN);
      strncpy(cur->host, peercom->senderHost, NAMELEN);
      strncpy(cur->nickname, peercom->additional, NAMELEN);
      cur->inUse = 0;
      cur->exit = 0;
      cur->next = NULL;
      pthread_mutex_lock(&usrMutex);
      if (insertUser(&userList, cur)<0)
        free(cur);
      pthread_mutex_unlock(&usrMutex);
      break;
    case IPMSG_RECVMSG:
      //
      break;
    case IPMSG_RELEASEFILES: //应该验证一下peer
    //取消发送文件请求（在发送列表中找到节点，shutdown它的TCP套接字）
      preSend = &sendFHead;
      pthread_mutex_lock(&sendFMutex);
      curSend = sendFHead.next;
      while ((curSend!=NULL)&&(curSend->packetNo!=atoi(peercom->additional)))
      {
        preSend = preSend->next;
        curSend = curSend->next;
      }
      
      if (curSend!=NULL)
      {
        curSend->cancelled = 1;
        if (curSend->tcpSock>0)
          shutdown(curSend->tcpSock, SHUT_RDWR);
      }
      pthread_mutex_unlock(&sendFMutex);
      break;
    case IPMSG_BR_EXIT://下线通知。
      pthread_mutex_lock(&usrMutex);
      delUser(&userList, peercom);
      pthread_mutex_unlock(&usrMutex);
      break;
    case IPMSG_NOOPERATION:
      //
      break;
    default:
      printf("\nno handle, %x\n", peercom->commandNo);
      break;
    }
    deCommand(peercom);
    free(peercom);
    peercom = NULL;
  }
  
}

//数据清理，清理已发送完成的文件信息节点，释放内存空间
void destroyer()
{
  gsNode *preSend, *curSend, *preGet, *curGet;
  filenode *curFile;
  user *curUsr, *preUsr;
  
  preSend = &sendFHead;
  pthread_mutex_lock(&sendFMutex);
  curSend = sendFHead.next;
  while (curSend!=NULL)
  {
    if ((curSend->cancelled == 1) && (curSend->transferring==0))
    {
      preSend->next = curSend->next;
      deGsNode(curSend);
      free(curSend);
    }
    else preSend = preSend->next;
    
    curSend = preSend->next;
  }
  pthread_mutex_unlock(&sendFMutex);
  
  
  preGet = &getFHead;
  pthread_mutex_lock(&getFMutex);
  curGet = getFHead.next;
  while (curGet!=NULL)
  {
    if ((curGet->cancelled==1) &&(curGet->transferring==0))
    {
      preGet->next = curGet->next;
      deGsNode(curGet);
      free(curGet);
    }
    else preGet = preGet->next;
    
    curGet = preGet->next;
  }
  pthread_mutex_unlock(&getFMutex);

  preUsr = &userList;
  pthread_mutex_lock(&usrMutex);
  curUsr = userList.next;
  while (curUsr!=NULL)
  {
    if ((curUsr->exit==1) && (curUsr->inUse==0))
    {
      preUsr->next = curUsr->next;
      free(curUsr);
    }
    else preUsr = preUsr->next;
    
    curUsr = preUsr->next;
    
  }
  pthread_mutex_unlock(&usrMutex);
}



void* cleaner(void *option)
{
  gsNode *preSend, *curSend, *preGet, *curGet;
  filenode *curFile;
  user *curUsr, *preUsr;
  
  while(1)
  {
    sleep(30); //半分钟一次
    destroyer();
  }
  
}

//初始化udp和tcp
int initSvr()
{
  struct sockaddr_in server;
  char targetHost[NAMELEN];
  const int on=1;

  msgSock = socket(AF_INET, SOCK_DGRAM, 0);  //UDP for Msg
  
  tcpSock = socket(AF_INET, SOCK_STREAM, 0); //TCP for File
  
  server.sin_family = AF_INET;
  server.sin_port = htons(IPMSG_DEFAULT_PORT);
  server.sin_addr.s_addr = htonl(INADDR_ANY);
  
  if (setsockopt(msgSock, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on))<0)
  {
    printf("initSvr: Socket options set error.\n");
    exit(1);
  }

  if (bind(msgSock, (struct sockaddr*)&server, sizeof(server))<0)
  {
    printf("initSvr: Udp socket bind error.\n");
    exit(1);
  }

  if (bind(tcpSock, (struct sockaddr*)&server, sizeof(server))<0)
  {
    printf("initSvr: Tcp socket bind error.\n");
    exit(1);
  }

  if (listen(tcpSock, 10)<0)
  {
    printf("initSvr: Tcp listen error.\n");
    exit(1);
  }
  
  //printf("Commands: list(ls) talk(tk) sendfile(sf)\n"
  //"Commands: getfile(gf) refresh(rf) ceaseSend(cs) quit(q)\n");
  printf(IMHELP);
}

int main (int argc, char *argv [])
{
  pthread_t procer, recver, iter, fler, cler;
  int *fSock;
  int tmp;
  pthread_attr_t attr;
  
  uname(&sysName);    //得到系统名
  pwd = getpwuid(getuid());        //得到用户登录信息
  getcwd(workDir, sizeof(workDir));        //得到用户当前工作目录

  utf8 = 0;
  if (setlocale(LC_CTYPE, ""))
    if (!strcmp(nl_langinfo(CODESET), "UTF-8"))        //设置系统字符集
      utf8 = 1;
  
  initGsNode(&sendFHead);        //初始化文件发送队列
  initCommand(&mList.comHead, IPMSG_NOOPERATION);        //初始化消息发送队列
  mList.comTail = &mList.comHead;        
  userList.next = NULL;        //初始化用户列表
  sem_init(&waitNonEmpty, 0, 0);
  sem_init(&waitNonFull, 0, MSGLIMIT);

  initSvr();    //初始化套接字
  
  //主要线程的建立
  pthread_create(&procer, NULL, &processor, &msgSock); 
  pthread_create(&recver, NULL, &receiver, &msgSock);
  pthread_create(&iter, NULL, &interacter, NULL);
  pthread_create(&cler, NULL, &cleaner, NULL);
  login();    //登录，向广播地址发送IPMSG_BR_ENTRY命令

  //发送文件线程的建立
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  while(1)
  {
    if ((tmp=accept(tcpSock, NULL, NULL))<0)
      printf("Tcp accept error.\n");
    else
    {
      fSock = (int *)malloc(sizeof(int));
      *fSock = tmp;
      pthread_create(&fler, &attr, &sendData, fSock);
    }
    
  }

  //同步线程
  pthread_join(procer, NULL);
  pthread_join(recver, NULL);
  pthread_join(iter, NULL);
  pthread_join(cler, NULL);
  return 0;
}

/**********************************************************
 *Filename: send_receive.c
 *Author:   星云鹏
 *Date:     2008-05-15
 *
 *消息、文件（夹）的发送和接收
 *********************************************************/

#include "send_receive.h"
#include "ipmsg.h"
#include "users.h"
#include "coms.h"

#include <sys/utsname.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <dirent.h>
#include <errno.h>
#include <pwd.h>
#include <sys/utsname.h>
#include <signal.h>
#include <pthread.h>


//////////////////////////////////////////////////
//发送udp包
void* sendMsg(command* com)
{
  char buf[COMLEN];
  int len, temp;
  
  msgCreater(buf, com, sizeof(buf)); //建立发送的包（包装com结构体为字符串）
  len = strlen(buf);
  if (com->commandNo & IPMSG_FILEATTACHOPT) //如果带有附件（发送文件请求）
      temp = strlen(buf+len+1);
      
      sendto(msgSock, buf, len+temp+2, 0,
             (struct sockaddr*)&com->peer, sizeof(com->peer));
     }
     //发送普通信息
  else sendto(msgSock, buf, len+1, 0,
              (struct sockaddr*)&com->peer, sizeof(com->peer));
}

//////////////////////////////////////////////////
//聊天
int saySth()
{
  char buf[100]; //临时输入区
  char gMsg[MSGLEN];
  command com;
  user *cur=NULL;
  int remainder; //扩展区剩余空间
  int pos;       //扩展区的当前输入位置
  int who, temp, count;
  int sended;      //标记此包是否已经发过
  user *pusers[50];

  //列出并且选择要聊天的用户
  //列出并且选择要聊天的用户
  printf("\n*Talking mode\n"
         "*Continuous Enter to send msg,\n"
         "*Ctrl+D to quit conversation.\n");
  
  pthread_mutex_lock(&usrMutex);
  count = listUsers(pusers, &userList, sizeof(pusers)/sizeof(pusers[0]), 0);
  pthread_mutex_unlock(&usrMutex);
  
  who = inputNo(1, count, 1, "Please input user No.[1]:");
  
  if (who>0)
  {
    cur = pusers[who-1];
    //初始化消息命令
    initCommand(&com, IPMSG_SENDMSG|IPMSG_SENDCHECKOPT);
    memcpy(&com.peer, &cur->peer, sizeof(com.peer));
    
    remainder = MSGLEN;
    pos = 0;
    sended = 1;
    
    while(1)
    {
      printf("(talking with %s):", cur->name);
      if (fgets(buf, sizeof(buf), stdin)==NULL) //等待用户输入消息
        break;
      if (buf[0] != '\n')
      {
      //把消息放入发送命令的扩展区
        strncpy(com.additional+pos, buf, remainder);
        temp = strlen(com.additional+pos);
        pos += temp;
        remainder -= temp;
        sended = 0;
      }

      if ((buf[0]=='\n') || (remainder<=1))
      {
        if (!sended) //消息填写完成，调用sendMsg函数发送包含消息的UDP包
        {
          com.packetNo = (unsigned int)time(NULL);
          sendMsg(&com);
          sended = 1;
          printf("Message sent.\n");
        }
        remainder = sizeof(com.additional); //恢复扩展区大小
        pos = 0;
      }
      
    }
  }
  
    puts("\nEnd conversation.\n");
    
    pthread_mutex_lock(&usrMutex);
    unListUsers(pusers, count);
    pthread_mutex_unlock(&usrMutex);
  
}

/////////////////////////////////////////////////
//文件发送
//选择要传输的文件

int selectFiles()
{
  command com;
  user *cur=NULL;
  int  who, count, flag, fileType;
  unsigned int fileNo;
  char fileName[FILENAME];
  struct stat fileAttr;
  char *strtmp;
  filenode *fntmp, *head, *tail;
  gsNode *newTask;
  user *pusers[50];
  
  printf("\n*Sending mode\n"
         "*Continuous Enter to send file,\n"
         "*Ctrl+D to quit.\n"); //输出提示
  
  pthread_mutex_lock(&usrMutex);
  count = listUsers(pusers, &userList, sizeof(pusers)/sizeof(pusers[0]), 0); //列出用户列表
  pthread_mutex_unlock(&usrMutex);

  //选择要发送的用户，默认第一个
  who = inputNo(1, count, 1, "Please input user No.[1]:");

  if (who>0)
  {
    
    cur = pusers[who-1];
  //初始化命令，设置IPMSG_SENDMSG|IPMSG_FILEATTACHOPT用于表示有文件发送
    initCommand(&com, IPMSG_SENDMSG|IPMSG_FILEATTACHOPT);
    memcpy(&com.peer, &cur->peer, sizeof(com.peer));
    
    printf("To send file to %s(%s).\nPlease select file to send:\n", cur->name, cur->host);
    
    //建立发送文件信息节点
    newTask = (gsNode*)malloc(sizeof(gsNode));
    initGsNode(newTask);
    newTask->packetNo = com.packetNo;
    
    fileNo = 0;
    head = com.fileList;
    tail = com.fileList;
    
    while (1)
    {
      if (fgets(fileName, FILENAME, stdin) == NULL) //等待用户输入需要发送的文件（夹）名字。C+d取消发送
      {
        free(newTask);
        newTask = NULL;
        while (head!=NULL)
        {
          tail = head;
          head = head->next;
          free(tail);
        }
        break;
      }

       transfStr(fileName, 0); //去除前后空白字符
       
      if (fileName[0]=='\0')
        break;
      
      //读取文件名的信息，写入struct stat结构体
     if (lstat(fileName, &fileAttr)<0)
      {
        printf("Get file attributes error.\n");
        continue;
      }

      //确定文件类型，是文件还是文件夹
      if (S_ISREG(fileAttr.st_mode))
        fileType = 1;
      else if (S_ISDIR(fileAttr.st_mode))
        fileType = 2;
      else
      {
        fileType = -1;
        printf("Unsupported file type.\n");
        continue;
      }
      
      //建立filenode（文件信息）节点
      if (tail == NULL)
        head = tail = (filenode*)malloc(sizeof(filenode));
      else
      {
        tail->next = (filenode*)malloc(sizeof(filenode));
        tail = tail->next;
      }
      
      //把上边得到的struct stat文件信息填入filenode
      tail->next = NULL;
      tail->fileNo = fileNo;
      strncpy(tail->fileName, fileName, sizeof(tail->fileName));
      snprintf(tail->fileSize, sizeof(tail->fileSize), "%x", fileAttr.st_size);
      snprintf(tail->mtime, sizeof(tail->mtime), "%x", fileAttr.st_mtime);
      tail->fileType = fileType;

      fileNo++;
    }
    
    if (head==NULL)
    {
      if (newTask!=NULL)
        free(newTask);
    }
    else 
    {
    //初始化newTask的filenode成员
      newTask->fileList.next = com.fileList = head;
      pthread_mutex_lock(&sendFMutex); //lock
      newTask->next = sendFHead.next; //把newTask加入sendFHead列表
      sendFHead.next = newTask;
      pthread_mutex_unlock(&sendFMutex); //unlock

      if (newTask->fileList.next!=NULL)
      {
        sendMsg(&com); //可以放lock外面，发送信息给对方
        printf("\nWaiting to transfer.\n");
      }
    }
  }

  pthread_mutex_lock(&usrMutex);
  unListUsers(pusers, count);
  pthread_mutex_unlock(&usrMutex);
  
}

//文件或文件夹发送
void* sendData(void* option)
{
  int fSock = *(int *)option;
  char buf[RECFRG], fileName[FILENAME];
  int i, commandNo, realCount, offset, curErr;
  unsigned int packetNo, fileNo;
  filenode *preFile, *curFile;
  gsNode *preSend, *curSend;
  FILE* sfile;
  sigset_t mask, oldmask;

  free(option);
  
  sigemptyset(&mask);
  sigaddset(&mask, SIGPIPE);
  if (pthread_sigmask(SIG_BLOCK, &mask, &oldmask) != 0)
    printf("SIG_BLOCK error.\n");
  
  //以tcp的方式接受传输请求
  for (i=0;i<4;i++)
  {
    if (readDelimiter(fSock, buf, RECFRG, ':')<=0)
    {
      printf("Transfer cancelled.\n");
      shutdown(fSock, SHUT_RDWR);
      return NULL;
    }  
  }

  if (readDelimiter(fSock, buf, RECFRG, ':')<=0)
  {
    printf("Transfer cancelled.\n");
    shutdown(fSock, SHUT_RDWR);
    return NULL;
  }
  
  commandNo = atoi(buf);

  if (!(commandNo & IPMSG_GETFILEDATA))
  {
    printf("Invalid request.\n");
    shutdown(fSock, SHUT_RDWR);
    return NULL;
  }
  
  
  if (readDelimiter(fSock, buf, RECFRG, ':')<=0)
  {
    printf("Transfer cancelled.\n");
    shutdown(fSock, SHUT_RDWR);
    return NULL;
  }
  
  sscanf(buf, "%x", &packetNo);

  if (readDelimiter(fSock, buf, RECFRG, ':')<0)
  {
    printf("Transfer cancelled.\n");
    shutdown(fSock, SHUT_RDWR);
    return NULL;
  }
  sscanf(buf, "%x", &fileNo);

  pthread_mutex_lock(&sendFMutex);
  
  preSend = &sendFHead;
  curSend = sendFHead.next;

  while ((curSend != NULL) &&
         (curSend->packetNo!=packetNo || curSend->transferring==1 ||
         curSend->cancelled==1)){
    preSend = preSend->next;
    curSend = curSend->next;
  }
  
  if (curSend != NULL)
  {
    curSend->transferring = 1;
    curSend->tcpSock = fSock;
    pthread_mutex_unlock(&sendFMutex);
    
    curFile = curSend->fileList.next;
    preFile = &curSend->fileList;
    while ((curFile!=NULL) && (curFile->fileNo!=fileNo))
    {
      preFile = preFile->next;
      curFile = curFile->next;
    }
    
    if (curFile != NULL)
    {
      getFileName(fileName, curFile->fileName, sizeof(fileName));
      printf("\nStart transferring %s.\n", fileName);
      switch (curFile->fileType)
      {
      case 1: //发送文件
        if (readDelimiter(fSock, buf, RECFRG, ':')<=0) //offset似乎没用上
        {
          printf("Transfer cancelled.\n");
          shutdown(fSock, SHUT_RDWR);
          return NULL;
        }
        sscanf(buf, "%x", &offset);
        
        sfile = fopen(curFile->fileName, "r");
        
        while ((realCount = fread(buf, 1, RECFRG, sfile))>0)
          if (writen(fSock, buf, realCount)<0)
          {
            curErr = errno;
            break;
          }
        break;
      case 2: //发送文件夹
        curErr = traverseDir(fSock, curFile->fileName, sendDir); 
        break;
      default:
        break;
      }
    }
  }
  else pthread_mutex_unlock(&sendFMutex);

  pthread_mutex_lock(&sendFMutex);
  if ((curSend!=NULL) && (curSend->cancelled==1))
  {
    preSend->next = curSend->next;
    deGsNode(curSend);
    free(curSend);
    pthread_mutex_unlock(&sendFMutex);
    shutdown(fSock, SHUT_RDWR);
    printf("Transfer canceled.\n");
    return NULL;
  }
  
  if ((curErr<0) || (errno == ECONNRESET) || (errno == EPIPE)) //error or connection reset by peer
  {
    if (curFile!=NULL)
    {
      curSend->transferring = 0;
      curSend->tcpSock = -1;
    }
    pthread_mutex_unlock(&sendFMutex);
    shutdown(fSock, SHUT_RDWR);
    printf("Peer needs retransfer.\n");
    return NULL;
  }
  
  if (curFile!=NULL)
  {
    printf("\n%s is transferred.\n", fileName);
    preFile->next = curFile->next;
    free(curFile);
  }
  
  
  if (curSend!=NULL && curSend->fileList.next == NULL)
  {
    preSend->next = curSend->next;
    deGsNode(curSend);
    free(curSend);
  }
  else if (curSend!=NULL)
  {
    curSend->transferring = 0;
    curSend->tcpSock = -1;
  }
  pthread_mutex_unlock(&sendFMutex);
  
  shutdown(fSock, SHUT_RDWR);
}

//发送文件夹

int sendDir(int fSock, const char* fullpath, int fileSize, int fileType)
{
  char strtmp[FILENAME], strformat[50], strdata[RECFRG], fileName[FILENAME];
  int tmp, headLen, packetNo;
  FILE *sf;

  if (getFileName(strtmp, fullpath, sizeof(strtmp)) < 0)
  {
    printf("\nFilename is too long.\n");
    return -1;
  }

  addColon(strtmp, sizeof(strtmp));
  if (utf8)
    u2g(strtmp, sizeof(strtmp),
        fileName, sizeof(fileName));
  else strncpy(fileName, strtmp, sizeof(fileName));
  
  headLen = (strlen(fileName)+1) + (HL_HEADERSIZE+1) +
    (HL_FILETYPE+1) + (HL_FILESIZE+1) + 2*(HL_1416+1);
  packetNo = (unsigned int)time(NULL); //简化了，属性值并不准确
  snprintf(strformat, sizeof(strformat), "%%0%dx:%%s:%%0%dx:%%0%dx:14=%%0%dx:16=%%0%dx:",
           HL_HEADERSIZE, HL_FILESIZE, HL_FILETYPE, HL_1416-3, HL_1416-3);
  
  tmp = snprintf(strdata, sizeof(strdata), strformat,
           headLen, fileName, fileSize, fileType, packetNo, packetNo);
  
  switch (fileType)
  {
  case 1:
    if ((sf = fopen(fullpath, "r")) == NULL)
    {
      printf("file open error.\n");
      return -1;
    }
    if (writen(fSock, strdata, tmp)<0)
      return -1;
    while ((tmp = fread(strdata, 1, RECFRG, sf))>0)
    {
      if (writen(fSock, strdata, tmp)<0)
        return -1;
    }
    fclose(sf);
    break;
  case 2:
   
    //break;
  case 3:
    if (writen(fSock, strdata, tmp)<0)
      return -1;
    break;
  default:
    break;
  }
  return 0;
}

//遍历要发送的文件夹，利用上面的回掉函数发送
int traverseDir(int fSock, char* fullpath, Mysnd snd) //FILENAME指定了fullpath的容量
{
  struct stat fst;
  struct dirent *dirp;
  char *ptr;
  DIR  *dp;
  int tmp;
  

  if (lstat(fullpath, &fst)<0)
  {
    printf("\nDir: get attributes error.\n");
    return -1;
  }
  
  if (S_ISREG(fst.st_mode))
    return snd(fSock, fullpath, fst.st_size, 1);
  else if (S_ISDIR(fst.st_mode))
  {
    if (snd(fSock, fullpath, 0, 2)<0)
      return -1;
  }
  else return -1;

  tmp = strlen(fullpath);
  ptr = fullpath + tmp;
  
  *ptr++ = '/'; //tmp+1
  *ptr = '\0';

  if ((dp=opendir(fullpath)) == NULL)
  {
    printf("\nDir: open error.\n");
    return -1;
  }

  while ((dirp=readdir(dp)) != NULL)
  {
    if (strcmp(dirp->d_name, ".")==0 ||
        strcmp(dirp->d_name, "..")==0)
      continue;

    strncpy(ptr, dirp->d_name, FILENAME-tmp-1);
    if (traverseDir(fSock, fullpath, snd)<0)
      return -1;
  }

  ptr[-1] = '\0'; //还原fullname
  snd(fSock, ".", 0, 3);
  if (closedir(dp) < 0)
  {
    printf("\nDir: close error.\n");
    return -1;
  }
  return 0;
}

//列举待发送文件
int listSFiles(gsNode **list, gsNode *gs, int size)
{
  filenode *curFile;
  int tmp=0;

  while ((gs!=NULL)&&(tmp<size))
  {
    if ((gs->cancelled==0))
    {
      *list++ = gs;
      tmp++;
    }
    gs = gs->next;
  }
  
  return tmp;
  
}

//取消文件传输
int ceaseSend()
{
  gsNode *gsList[CAPACITY], *cur;
  int tmp, index, count;
  char buf[FILENAME];
  filenode *curFile;

  while(1)
  {
    pthread_mutex_lock(&sendFMutex);
    count = listSFiles(gsList, sendFHead.next, sizeof(gsList)/sizeof(gsList[0])-1);
    pthread_mutex_unlock(&sendFMutex);
    
    if (count == 0)
      return 0;
    else
    {
      printf("\n++++++++++++++++++++\n");
      printf("Files to send:\n");
      for(tmp=1;tmp<=count;tmp++)
      {
        printf("%d. ", tmp);
        curFile = (*(gsList+tmp-1))->fileList.next;
        while (curFile!=NULL)
        {
          printf("%s ", curFile->fileName);
          curFile = curFile->next;
        }
        printf("\n");
      }
      printf("++++++++++++++++++++\n");
    }

    index = inputNo(1, count, 1,
                    "Which file(s) to cancel?(Ctrl+D to quit)\nNumber[1]:");

    if (index<0)
      return -1;

    pthread_mutex_lock(&sendFMutex);
    (*(gsList+index-1))->cancelled = 1;
    if ((*(gsList+index-1))->tcpSock>=0)
      shutdown((*(gsList+index-1))->tcpSock, SHUT_RDWR);
    pthread_mutex_unlock(&sendFMutex);
  }
}


////////////////////////////////////////////////////
//文件接收
//选择要接收的文件
int recvFiles()
{
  gsNode *gsList[CAPACITY], *cur;
  int tmp, index, count;
  char buf[FILENAME];
  struct stat dirAttr;
  pthread_t gFile;
  filenode *curFile;
  pthread_attr_t attr;
  
  while(1)
  {//访问getFHead列表，列出等待接受的文件信息
    pthread_mutex_lock(&getFMutex);
    //把待接收文件信息节点存入gsList
    count = listGFiles(gsList, getFHead.next, sizeof(gsList)/sizeof(gsList[0])-1);
    pthread_mutex_unlock(&getFMutex);
    
    if (count == 0)
      return -1;
    else
    {//待接受文件名和编号
      printf("\n++++++++++++++++++++\n");
      printf("Files to get:\n");
      for(tmp=1;tmp<=count;tmp++)
      {
        printf("%d. ", tmp);
        curFile = (*(gsList+tmp-1))->fileList.next;
        while (curFile!=NULL)
        {
          printf("%s ", curFile->fileName);
          curFile = curFile->next;
        }
        printf("\n");
      }
      printf("++++++++++++++++++++\n");
    }
    //选择需要接收的文件，默认第一个。
    index = inputNo(1, count, 1,
                    "Which file(s) to get?(Ctrl+D to quit)\nNumber[1]:");

    if (index<0)
      return -1;
    
    while(1)
    {
      printf("Where do you want to save?(Ctrl+D to quit)\nTarget dir[.]:");
      if (fgets(buf, sizeof(buf), stdin)==NULL) //输入保存路径，默认当前目录
        return -1;

      transfStr(buf, 0); //去除前后空白字符
      
      if (buf[0]=='\0')
      {
        buf[0]='.';
        buf[1]='\0';
      }
    //检查存储路径是否合法
      if ((stat(buf, &dirAttr)<0) ||
          !S_ISDIR(dirAttr.st_mode) ||
          (access(buf, W_OK)<0))
        printf("Invalid directory. Please input again.\n");
      else break;
    }
    
    cur = *(gsList+index-1);
    tmp = strlen(buf);
    pthread_mutex_lock(&getFMutex);
    if (cur->cancelled == 0)
    {//设置节点信息
      cur->targetDir = (char*)malloc(tmp+1);
      strncpy(cur->targetDir, buf, tmp+1);
      cur->transferring = 1;
    }
    //启动getData线程，开始接收文件
    pthread_mutex_unlock(&getFMutex);
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    pthread_create(&gFile, &attr, &getData, cur);
  }

}

//文件接收线程
void* getData(void* option)
{
  gsNode *gList = (gsNode *)option;
  filenode *head=&gList->fileList, *cur;
  int fileType, tmp;
  command com;

  printf("\nStart getting files.\n");
  while((cur=head->next) != NULL)
  {//查看文件类型（文件还是文件夹），用不同的函数接收
    fileType = cur->fileType & 0x03;
    switch (fileType)
    {
    case 1:
      tmp=getFile(cur, gList);//接收文件
      break;
    case 2:
      tmp=getDir(cur, gList);//接收文件夹
      break;
    default:
      tmp = -1;
      printf("\nUnsupported file type.\n%s fails to be transfered.\n", cur->fileName);
      break;
    }
   //接收错误（出现了套接字建立错误，链接错误，传输错误等） 
    if (tmp<0)
    {
      initCommand(&com, IPMSG_RELEASEFILES); //设置取消传输
      snprintf(com.additional, sizeof(com.additional), "%d", gList->packetNo);
      memcpy(&com.peer, &gList->peer, sizeof(com.peer));
      sendMsg(&com);
      pthread_mutex_lock(&getFMutex);
      //设置结构体成员标识参数
      gList->cancelled = 1;
      gList->transferring = 0;
      pthread_mutex_unlock(&getFMutex);
      printf("\n%s fails to be transfered.\n", cur->fileName);
      return NULL;
    }
    
    printf("\n%s is transferred.\n", cur->fileName);
    head->next = cur->next;
    free(cur);
  }

  pthread_mutex_lock(&getFMutex);
  gList->cancelled = 1; //其实是已经完成，成功后设置传输成功。
  gList->transferring = 0;
  pthread_mutex_unlock(&getFMutex);
  
  printf("File reception done.\n");
}

//接收文件
int getFile(void* option, gsNode *gList)
{
  int sockfd, readBytes;
  char buf[COMLEN];
  char recvs[RECFRG];
  filenode *head = (filenode*)option;
  command com;
  struct sockaddr_in peer;
  long fileSize, offset=0;
  FILE* recvFile;
    //初始化文件接收命令
  initCommand(&com, IPMSG_GETFILEDATA);  //Regular file
  snprintf(com.additional, MSGLEN, "%x:%x:%x", gList->packetNo, head->fileNo, offset);
  //建立TCP套接字
  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  bzero(&peer, sizeof(peer));
  peer.sin_family = AF_INET;
  peer.sin_port = htons(IPMSG_DEFAULT_PORT);
  memcpy(&peer.sin_addr, &gList->peer.sin_addr, sizeof(peer.sin_addr));
  //连接
  if (connect(sockfd, (struct sockaddr*)&peer, sizeof(peer))<0)
  {
    printf("File connect error.\n");
    return -1;
  }
  
  msgCreater(buf, &com, sizeof(buf));//创建发送消息

  if (writen(sockfd, buf, strlen(buf)+1)<0)    //接收文件命令消息发送给对方
    return -1;

  sscanf(head->fileSize, "%x", &fileSize);

  if ((recvFile = fopen(head->fileName, "w+")) == NULL) //建立文件描述符
  {
    printf("getFile: file create error.\n");
    return -1;
  }

  while (fileSize>0)
  {
  //从套接字接收文件内容
    readBytes = fileSize < RECFRG ? fileSize:RECFRG;
    if ((readBytes = readn(sockfd, recvs, readBytes))<0) //RECFRG
    {
      printf("getFile: data transfer error.\n");
      return -1;
    }
    //接收到的内容写入文件描述符
    fwrite(recvs, 1, readBytes, recvFile);
    fileSize -= readBytes;
  }
  fclose(recvFile); //关闭文件描述符
  
  close(sockfd); //关闭套接字
  return 0;
}

//接收文件夹时分析，头部
int parseHeader(filenode *pfn, char * recvs)
{
  char *strhead, *strtmp, gMsg[FILENAME];
  int i=0;
  
  strhead = recvs;
  while (i<3) //分析前3段
  {
    strtmp = strchr(strhead, ':');
    if (strtmp == NULL)
      return -1;
    *strtmp = '\0';

    switch (i)
    {
    case 0:
      
      strncpy(gMsg, strhead, sizeof(gMsg));
      delColon(gMsg, sizeof(gMsg));
      if (utf8)
        g2u(gMsg, sizeof(gMsg),
            pfn->fileName, sizeof(pfn->fileName));
      else strncpy(pfn->fileName, gMsg, sizeof(pfn->fileName));
      break;
    case 1:
      //sscanf(strhead, "%x", &pfn->fileSize);
      strncpy(pfn->fileSize, strhead, sizeof(pfn->fileSize));
      break;
    case 2:
      sscanf(strhead, "%x", &pfn->fileType);
      break;
      //case 3: //进行了简化
      // strncpy(pfh->h14, strhead+3, sizeof(pfh->h14));
      //break;
      //case 4:
      //strncpy(pfh->h16, strhead+3, sizeof(pfh->h16));
      //break;
    default:
      break;
    }

    strhead = strtmp+1;
    i++;
  }

  strncpy(pfn->otherAttrs, strhead, sizeof(pfn->otherAttrs));
  
  return 0;
}

//接收文件夹
int getDir(void *option, gsNode *gList)
{
  int sockfd, readBytes, headerSize, fileType, dirDepth=0, tmp;
  char buf[COMLEN], recvs[RECFRG], hSize[HSIZE], fullPath[2*FILENAME];
  filenode *head = (filenode*)option, *cur, fn;
  command com;
  struct sockaddr_in peer;
  long  offset=0, fileSize;
  FILE* recvFile;

  strncpy(fullPath, gList->targetDir, sizeof(fullPath)); //文件路径写入fullPath
  
  initCommand(&com, IPMSG_GETDIRFILES); //Direcotry
  
  snprintf(com.additional, MSGLEN, "%x:%x:%x", gList->packetNo, head->fileNo, offset);
  
  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  bzero(&peer, sizeof(peer));
  peer.sin_family = AF_INET;
  peer.sin_port = htons(IPMSG_DEFAULT_PORT);
  memcpy(&peer.sin_addr, &gList->peer.sin_addr, sizeof(peer.sin_addr));
  
  if (connect(sockfd, (struct sockaddr*)&peer, sizeof(peer))<0)
  {
    printf("File connect error.\n");
    return -1;
  }

  msgCreater(buf, &com, sizeof(buf));
  
  if (writen(sockfd, buf, strlen(buf)+1)<0)
    return -1;
  //以上处理同getfile
  do
  {
    //检验路径名是否合法
    tmp = strlen(fullPath);
    if (tmp+1>=sizeof(fullPath))
    {
      printf("getDir: target directory is too lang.\n");
      return -1;
    }
    if (fullPath[tmp-1]!='/')
    {
      fullPath[tmp] = '/';
      fullPath[tmp+1] = '\0';
    }
  
    readBytes = readDelimiter(sockfd, hSize, HSIZE, ':'); //读取定界符（定界符见协议），读遇到的以一个分界符之前的内容
    sscanf(hSize, "%x", &headerSize);//把字符串长度写入headerSize
    if (headerSize<=0 || headerSize<=readBytes || headerSize>RECFRG) //保护、防止溢出
      return -1;
    readn(sockfd, recvs, headerSize-readBytes);//读取
    recvs[headerSize-readBytes]='\0';
    
    if (parseHeader(&fn, recvs)<0) //分析接收到的内容。
    {
      printf("getDir: Parse protocol failed.\n");
      return -1;
    }
    
    switch (fn.fileType & 0x03) //分析文件类型
    {
    case IPMSG_FILE_REGULAR:

      strncat(fullPath, fn.fileName, sizeof(fullPath)-tmp-1);
      if ((recvFile = fopen(fullPath, "w+")) == NULL)
      {
        printf("Open error.\n");
        return -1;
      }
      
      sscanf(fn.fileSize, "%x", &fileSize);
      while (fileSize>0)
      {
        readBytes = fileSize < RECFRG ? fileSize:RECFRG;
        if ((readBytes = readn(sockfd, recvs, readBytes))<0) //RECFRG
        {
          printf("File read error.\n");
          return -1;
        }
        
        fwrite(recvs, 1, readBytes, recvFile);
        fileSize -= readBytes;
      }
      fclose(recvFile);
      getParentPath(fullPath, sizeof(fullPath));
      break;
      
    case IPMSG_FILE_DIR:
      strncat(fullPath, fn.fileName, sizeof(fullPath)-tmp-1);
      tmp = strlen(fullPath);
      if (tmp+1>=sizeof(fullPath))
      {
        printf("getDir: target directory is too lang.\n"
               "Filename(%s) has been truncated.\n", fn.fileName);
        fullPath[tmp-1] = '/';
      }
      else
      {
        fullPath[tmp] = '/';
        fullPath[tmp+1] = '\0';
      }
      
      if (mkdir(fullPath, S_IRUSR|S_IWUSR|S_IXUSR))
      {
        printf("getDir: mkdir failed.\n");
        return -1;
      }
      
      dirDepth++;
      break;
      
    case IPMSG_FILE_RETPARENT:
      getParentPath(fullPath, sizeof(fullPath));
      dirDepth--;
      break;
      
    default:
      printf("Unsupported file type.\n");
      break;
    }
    
  }while(dirDepth>0);

  //close(sockfd);
  shutdown(sockfd, SHUT_RDWR);
  return 0;
}

//列举待接收文件
int listGFiles(gsNode **list, gsNode *gs, int size)
{
  filenode *curFile;
  int tmp=0;

  while ((gs!=NULL)&&(tmp<size))
  {
    if ((gs->transferring==0)&&(gs->cancelled==0))
    {
      *list++ = gs;
      tmp++;
    }
    gs = gs->next;
  }
  
  return tmp;
  
}


/////////////////////////////////////////////////
//登录（上线）
int login()
{
  command com;

  initCommand(&com, IPMSG_BR_ENTRY);
  
  com.peer.sin_family = AF_INET;
  com.peer.sin_port = htons(IPMSG_DEFAULT_PORT);
  
  if (inet_pton(AF_INET, allHosts, &com.peer.sin_addr)<0)
    printf("login: Ip error.\n");
  
  strncpy(com.additional, pwd->pw_name, MSGLEN);
  
  sendMsg(&com);
  
}

//退出（下线）
int logout()
{
  command com;

  initCommand(&com, IPMSG_BR_EXIT);
  
  com.peer.sin_family = AF_INET;
  com.peer.sin_port = htons(IPMSG_DEFAULT_PORT);
  
  if (inet_pton(AF_INET, allHosts, &com.peer.sin_addr)<0)
    printf("logout: error\n");

  strncpy(com.additional, pwd->pw_name, MSGLEN);
  
  sendMsg(&com);
  printf("Bye!\n");
  
}