@@ -1,5 +1,5 @@

 1.1.0:

- - large file transfer Tuning

+ - file transfer performance tuning

  - remote file delete function for makuosan

  - add --delete option for msync

  - add --sync   option for msync

@@ -126,6 +126,16 @@ char *stropcode(mdata *data)

   return(opcodestrlist[i]);

 }

+char *strackreq(mdata *data)

+{

+  char *ack = "ack";

+  char *req = "req";

+  if(data->head.flags & MAKUO_FLAG_ACK){

+    return(ack);

+  }

+  return(req);

+}

+

 int md5sum(int fd, unsigned char *digest)

 {

   int  rd;

@@ -714,7 +724,7 @@ int is_reg(char *path)

   return(0);

 }

-int set_guid(int uid, int gid, gid_t *gids)

+int set_guid(uid_t uid, gid_t gid, gid_t *gids)

 {

   size_t num;

@@ -72,11 +72,10 @@

 /*----- flags -----*/

 #define MAKUO_FLAG_ACK    1

 #define MAKUO_FLAG_CRYPT  2

-#define MAKUO_FLAG_WAIT   4

-#define MAKUO_FLAG_FMARK  8

-#define MAKUO_FLAG_DRYRUN 16

-#define MAKUO_FLAG_RECURS 32

-#define MAKUO_FLAG_SYNC   64

+#define MAKUO_FLAG_FMARK  4

+#define MAKUO_FLAG_DRYRUN 8

+#define MAKUO_FLAG_RECURS 16

+#define MAKUO_FLAG_SYNC   32

 /*----- sendstatus -----*/

 #define MAKUO_SENDSTATE_STAT       0  /* 更新確認待 */

@@ -158,8 +157,8 @@ typedef struct

 typedef struct

 {

   mhead head;

-  char  data[MAKUO_BUFFER_SIZE];

-  char *p;

+  uint8_t data[MAKUO_BUFFER_SIZE];

+  uint8_t *p;

 }__attribute__((packed)) mdata;

 typedef struct excludeitem

@@ -281,6 +280,7 @@ char    *strsstate(uint8_t n);

 char    *strrstate(uint8_t n);

 char    *strmstate(mdata *data);

 char    *stropcode(mdata *data);

+char    *strackreq(mdata *data);

 void     mprintf(const char *func, mfile *m);

 void     lprintf(int l, char *fmt, ...);

 void     cprintf(int l, mcomm *c, char *fmt, ...);

@@ -301,7 +301,7 @@ void     member_del(mhost *h);

 int      mrecv(int s);

 void     msend(int s, mfile *m);

 void     set_filestat(char *path, uid_t uid, gid_t gid, mode_t mode);

-int      set_guid(int uid, int gid, gid_t *gids);

+int      set_guid(uid_t uid, gid_t gid, gid_t *gids);

 int      set_gids(char *groups);

 int      seq_popmark(mfile *m, int n);

 int      seq_delmark(mfile *m, uint32_t seq);

@@ -321,14 +321,14 @@ int      ack_clear(mfile *m, int state);

 int      ack_check(mfile *m, int state);

 int      mtimeget(struct timeval *tv);

 int      mtimeout(struct timeval *tf, uint32_t msec);

-int      isexclude(char *fn, excludeitem *exclude, int dir);

-excludeitem *mfnmatch(char *str, excludeitem *exclude);

 int      data_safeget(mdata *data, void *buff, size_t size);

 int      data_safeget16(mdata *data, uint16_t *buff);

 int      data_safeget32(mdata *data, uint32_t *buff);

 int      data_safeset(mdata *data, void *buff, size_t size);

 int      data_safeset16(mdata *data, uint16_t val);

 int      data_safeset32(mdata *data, uint32_t val);

+int      isexclude(char *fn, excludeitem *exclude, int dir);

 excludeitem *exclude_add(excludeitem *exclude, char *pattern);

 excludeitem *exclude_del(excludeitem *e);

+excludeitem *mfnmatch(char *str, excludeitem *exclude);

@@ -37,7 +37,7 @@ mfile *mexec_with_dsync(mcomm *c, char *fn, int dryrun, int recurs, mhost *t)

 	  strcat(m->fn, fn);

   }

-  strcpy(m->mdata.data, m->fn);

+  strcpy((char *)(m->mdata.data), m->fn);

 	m->mdata.head.reqid  = getrid();

 	m->mdata.head.szdata = strlen(m->fn);

 	m->mdata.head.opcode = MAKUO_OP_DSYNC;

@@ -328,10 +328,12 @@ int mexec_send(mcomm *c, int n, int sync)

         if(*optarg >= '0' && *optarg <='9'){

           gid = atoi(optarg);

         }else{

-          for(j=0;moption.gids[j];j++){

-            if(!strcmp(optarg, moption.grnames[j])){

-              gid = moption.gids[j];

-              break;

+          if(moption.gids){

+            for(j=0;moption.gids[j];j++){

+              if(!strcmp(optarg, moption.grnames[j])){

+                gid = moption.gids[j];

+                break;

+              }

             }

           }

         }

@@ -478,7 +480,7 @@ int mexec_send(mcomm *c, int n, int sync)

   if((m->dryrun == 0) && (gid != -1)){

     if(m->fs.st_gid != gid){

       if(lchown(m->fn, -1, gid) == -1){

-        lprintf(0, "%s: chown error %d -> %d (%s)\n", __func__, m->fs.st_gid, gid, strerror(errno));

+        lprintf(0, "%s: chgrp error (%s) [%d->%d] %s\n", __func__, strerror(errno),  m->fs.st_gid, gid, m->fn);

       }else{

         m->fs.st_gid = gid;

       }

@@ -779,7 +781,8 @@ int mexec_status(mcomm *c, int n)

     if(snow > smax){

       snow = smax;

     }

-    cprintf(0, c, "  (ack) %s %s %s (%u:%u/%u) rid=%d\n", 

+    cprintf(0, c, "  (%s) %s %s %s (%u:%u/%u) rid=%d\n",

+      strackreq(&(m->mdata)), 

       stropcode(&(m->mdata)), 

       strmstate(&(m->mdata)), 

       m->fn, 

@@ -187,7 +187,7 @@ static void minit_password(char *filename, int n)

   }

   MD5_Init(&ctx);

   MD5_Update(&ctx, buff, strlen(buff));

-  MD5_Final(moption.password[n], &ctx);

+  MD5_Final((unsigned char *)(moption.password[n]), &ctx);

   if(read(f, buff, sizeof(buff))){

     lprintf(0, "%s: password too long %s\n", __func__, optarg);

     exit(1);

@@ -597,7 +597,12 @@ static void mrecv_req_send_data_write(mfile *m, mdata *r)

   if(write(m->fd, r->data, r->head.szdata) != -1){

     m->recvcount++;

   }else{

-    lprintf(0, "%s: write error seqno=%d size=%d fd=%d err=%d\n", __func__, (int)r->head.seqno, r->head.szdata, m->fd, errno);

+    lprintf(0, "%s: write error (%s) seqno=%d size=%d %s\n",

+      __func__,

+      strerror(errno), 

+      (int)(r->head.seqno), 

+      r->head.szdata,

+      m->fn);

     m->mdata.head.ostate = m->mdata.head.nstate;

     m->mdata.head.nstate = MAKUO_RECVSTATE_WRITEERROR;

     mrecv_req_send_data_write_error(m, r);

@@ -611,7 +616,11 @@ static void mrecv_req_send_data_retry(mfile *m, mdata *r)

   uint32_t  markcnt = m->markcount;

   lprintf(3, "%s: markcount=%04u recv=%06u size=%06u %s\n",

-    __func__, m->markcount, m->recvcount, m->seqnomax,  m->fn);

+    __func__,

+    m->markcount, 

+    m->recvcount, 

+    m->seqnomax,  

+    m->fn);

   a = mfins(0);

   if(!a){

@@ -661,10 +670,6 @@ static void mrecv_req_send_data(mfile *m, mdata *r)

   if(m->mdata.head.nstate != MAKUO_RECVSTATE_OPEN){

     return;

   }

-  if(r->head.flags & MAKUO_FLAG_WAIT){

-    mrecv_req_send_data_retry(m, r);

-    return;

-  }

   if(m->lickflag){

     if(seq_delmark(m, r->head.seqno)){

       mrecv_req_send_data_write(m, r);

@@ -824,6 +829,8 @@ static mfile *mrecv_req_send_create(mdata *data, struct sockaddr_in *addr)

   mfile *m;

   uint16_t fnlen;

   uint16_t lnlen;

+  uint32_t  ldev;

+  uint32_t  hdev;

   uint64_t  rdev;

   if(data->head.nstate != MAKUO_SENDSTATE_STAT){

@@ -841,8 +848,7 @@ static mfile *mrecv_req_send_create(mdata *data, struct sockaddr_in *addr)

   data->p = data->data;

   /* read mstat */

-  memcpy(&fs, data->p, sizeof(fs));

-  data->p += sizeof(fs);

+  data_safeget(data, &fs, sizeof(fs));

   /* stat = mstat */

   m->fs.st_mode  = ntohl(fs.mode);

@@ -855,21 +861,19 @@ static mfile *mrecv_req_send_create(mdata *data, struct sockaddr_in *addr)

   lnlen = ntohs(fs.lnlen);

   /* read filename */

-  memcpy(m->fn, data->p, fnlen);

+  data_safeget(data, m->fn, fnlen);

   m->fn[fnlen] = 0;

-  data->p += fnlen;

   /* read linkname */

-  memcpy(m->ln, data->p, lnlen);    

+  data_safeget(data, m->ln, lnlen);

   m->ln[lnlen] = 0;

-  data->p += lnlen;

   /* rdev */

-  rdev = ntohl(*(uint32_t *)(data->p));

-  data->p += sizeof(uint32_t);

-  rdev <<= 32;

-  rdev |= ntohl(*(uint32_t *)(data->p));

-  data->p += sizeof(uint32_t);

+  data_safeget32(data, &hdev);

+  data_safeget32(data, &ldev);

+  rdev  = hdev;

+  rdev <<=  32;

+  rdev |= ldev;

   m->fs.st_rdev = (dev_t)rdev;

   /* Number of blocks */

@@ -1376,22 +1380,6 @@ static void mrecv_req(mdata *data, struct sockaddr_in *addr)

 * Receive common functions (public)

 *

 *******************************************************************/

-int mrecv(int s)

-{

-  mdata  data;

-  struct sockaddr_in addr;

-  if(mrecv_packet(s, &data, &addr) == -1){

-    return(0);

-  }

-  lprintf(9, "%s: rid=%d %s %s\n", __func__, data.head.reqid, stropcode(&data), strmstate(&data));

-  if(data.head.flags & MAKUO_FLAG_ACK){

-    mrecv_ack(&data, &addr);

-  }else{

-    mrecv_req(&data, &addr);

-  }

-  return(1);

-}

-

 void mrecv_gc()

 {

   mhost *t = members;

@@ -1435,3 +1423,19 @@ void mrecv_clean()

   while(m=mrecv_mfdel(m));

 }

+int mrecv(int s)

+{

+  mdata  data;

+  struct sockaddr_in addr;

+  if(mrecv_packet(s, &data, &addr) == -1){

+    return(0);

+  }

+  lprintf(9, "%s: rid=%d %s %s\n", __func__, data.head.reqid, stropcode(&data), strmstate(&data));

+  if(data.head.flags & MAKUO_FLAG_ACK){

+    mrecv_ack(&data, &addr);

+  }else{

+    mrecv_req(&data, &addr);

+  }

+  return(1);

+}

+

@@ -77,6 +77,9 @@ static int msend_packet(int s, mdata *data, struct sockaddr_in *addr)

       return(1);

     }

     if(r == -1){

+      if(errno == EAGAIN){

+        return(-1);

+      }

       if(errno == EINTR){

         continue;

       }else{

@@ -165,8 +168,9 @@ static int msend_retry(mfile *m)

 /* send & free */

 static void msend_shot(int s, mfile *m)

 {

-  msend_packet(s, &(m->mdata), &(m->addr));

-  msend_mfdel(m);

+  if(msend_packet(s, &(m->mdata), &(m->addr)) == 1){

+    msend_mfdel(m);

+  }

 }

 /******************************************************************

@@ -182,8 +186,8 @@ static void msend_ack_ping(int s, mfile *m)

 static void msend_ack_send(int s, mfile *m)

 {

   if(m->markcount){

-    m->mdata.head.szdata = m->marksize * sizeof(uint32_t);

-    memcpy(m->mdata.data, m->mark, m->marksize * sizeof(uint32_t));

+    m->mdata.head.szdata = 0;

+    data_safeset(&(m->mdata), m->mark, m->marksize * sizeof(uint32_t));

   }

   msend_shot(s, m);

 }

@@ -195,13 +199,11 @@ static void msend_ack_md5(int s, mfile *m)

 static void msend_ack_dsync(int s, mfile *m)

 {

-  mprintf(__func__, m);

   msend_shot(s, m);

 }

 static void msend_ack_del(int s, mfile *m)

 {

-  mprintf(__func__, m);

   msend_shot(s, m);

 }

@@ -259,7 +261,7 @@ static void msend_req_send_break(int s, mfile *m)

 static void msend_req_send_stat_init(int s, mfile *m)

 {

   mstat    fs;

-  uint64_t rdev;

+  uint64_t dev;

   if(!m->comm){

     msend_mfdel(m);

@@ -273,7 +275,7 @@ static void msend_req_send_stat_init(int s, mfile *m)

   m->mdata.head.szdata += strlen(m->ln);

   m->mdata.head.szdata += sizeof(uint64_t);

   if(m->mdata.head.szdata > MAKUO_BUFFER_SIZE){

-    lprintf(0, "%s: buffer size over size=%d file=%s\n", __func__, m->mdata.head.szdata, m->fn);

+    lprintf(0, "%s: buffer size over size=%d file=%s\n",   __func__, m->mdata.head.szdata, m->fn);

     cprintf(0, m->comm, "error: buffer size over size=%d file=%s\n", m->mdata.head.szdata, m->fn);

     return;

   }

@@ -286,18 +288,14 @@ static void msend_req_send_stat_init(int s, mfile *m)

   fs.ctime = htonl(m->fs.st_ctime);

   fs.fnlen = htons(strlen(m->fn));

   fs.lnlen = htons(strlen(m->ln));

-  memcpy(m->mdata.p, &fs, sizeof(fs));

-  m->mdata.p += sizeof(fs);

-  strcpy(m->mdata.p, m->fn);

-  m->mdata.p += strlen(m->fn);

-  strcpy(m->mdata.p, m->ln);

-  m->mdata.p += strlen(m->ln);

-

-  rdev = (uint64_t)(m->fs.st_rdev);

-  *(uint32_t *)(m->mdata.p) = htonl((uint32_t)(rdev >> 32));

-  m->mdata.p += sizeof(uint32_t);

-  *(uint32_t *)(m->mdata.p) = htonl((uint32_t)(rdev & 0xFFFFFFFF));

-  m->mdata.p += sizeof(uint32_t);

+  dev = (uint64_t)(m->fs.st_rdev);

+

+  m->mdata.head.szdata = 0;

+  data_safeset(&(m->mdata), &fs, sizeof(fs));

+  data_safeset(&(m->mdata), m->fn, strlen(m->fn));

+  data_safeset(&(m->mdata), m->ln, strlen(m->ln));

+  data_safeset32(&(m->mdata), (uint32_t)(dev >> 32));

+  data_safeset32(&(m->mdata), (uint32_t)(dev & 0xFFFFFFFF));

   m->sendwait  = 1;

   m->initstate = 0;

   ack_clear(m, -1);