@@ -27,14 +27,14 @@ uint8_t opcodenumlist[]={MAKUO_OP_PING,

                          MAKUO_OP_DEL,

                          MAKUO_OPCODE_MAX};

-char *sstatestrlist[]={"SEND_STAT",

-                       "SEND_OPEN",

-                       "SEND_DATA",

-                       "SEND_MARK",

-                       "SEND_CLOSE",

-                       "SEND_LAST",

-                       "SEND_ERROR",

-                       "SEND_BREAK",

+char *sstatestrlist[]={"SEND_STAT   ",

+                       "SEND_OPEN   ",

+                       "SEND_DATA   ",

+                       "SEND_MARK   ",

+                       "SEND_CLOSE  ",

+                       "SEND_LAST   ",

+                       "SEND_ERROR  ",

+                       "SEND_BREAK  ",

                        "SEND_UNKNOWN"};

 uint8_t sstatenumlist[]={MAKUO_SENDSTATE_STAT,

@@ -47,21 +47,21 @@ uint8_t sstatenumlist[]={MAKUO_SENDSTATE_STAT,

                          MAKUO_SENDSTATE_BREAK,

                          MAKUO_STATE_MAX};

-char *rstatestrlist[] = {"RECV_NONE",

-                         "RECV_UPDATE",

-                         "RECV_SKIP",

-                         "RECV_OPEN",

-                         "RECV_MARK",

-                         "RECV_CLOSE",

-                         "RECV_IGNORE",

+char *rstatestrlist[] = {"RECV_NONE    ",

+                         "RECV_UPDATE  ",

+                         "RECV_SKIP    ",

+                         "RECV_OPEN    ",

+                         "RECV_MARK    ",

+                         "RECV_CLOSE   ",

+                         "RECV_IGNORE  ",

                          "RECV_READONLY",

-                         "RECV_BREAK",

-                         "RECV_MD5OK",

-                         "RECV_MD5NG",

+                         "RECV_BREAK   ",

+                         "RECV_MD5OK   ",

+                         "RECV_MD5NG   ",

                          "RECV_DELETEOK",

                          "RECV_DELETENG",

-                         "RECV_OPENERR",

-                         "RECV_READERR", 

+                         "RECV_OPENERR ",

+                         "RECV_READERR ", 

                          "RECV_WRITEERR", 

                          "RECV_CLOSEERR", 

                          "RECV_UNKNOWN"};

@@ -55,7 +55,7 @@

 #define MAKUO_MCAST_PORT  5000

 /*----- timeout -----*/

-#define MAKUO_SEND_TIMEOUT  5000    /* 再送間隔(ms)                                 */

+#define MAKUO_SEND_TIMEOUT  500    /* 再送間隔(ms)                                 */

 #define MAKUO_SEND_RETRYCNT 120    /* 再送回数                                     */

 #define MAKUO_PONG_TIMEOUT  180000 /* メンバから除外するまでの時間(ms)             */

 #define MAKUO_PONG_INTERVAL 45000  /* PING送信間隔(ms)                             */

@@ -40,7 +40,9 @@ int mexec_scan_cmd(int fd, char *buff)

     if(FD_ISSET(fd,&fds)){

       r = write(fd, cmd, size);

       if(r == -1){

-        lprintf(0, "%s: commend write error! %s", __func__, buff);

+        lprintf(0, "%s: commend write error! %s", 

+          __func__, 

+          buff);

         return(-1);

       }

       size -= r;

@@ -316,9 +318,13 @@ int mexec_send(mcomm *c, int n)

 	if(lstat(fn, &m->fs) == -1){

 	  cprintf(0, c, "error: file not found %s\n", fn);

-		lprintf(1, "%s: lstat() error argc=%d cmd=%s\n", __func__, c->argc[n], c->cmdline[n]);

-    for(i=0;i<c->argc[n];i++)

+		lprintf(1, "%s: lstat() error argc=%d cmd=%s\n",

+      __func__, 

+      c->argc[n], 

+      c->cmdline[n]);

+    for(i=0;i<c->argc[n];i++){

 		  lprintf(1, "%s: read error argv[%d]=%s\n", __func__, i, c->parse[n][i]);

+    }

 		lprintf(0, "%s: read error file=%s\n", __func__, fn);

 		mfdel(m);

     return(0);

@@ -698,34 +704,42 @@ int mexec_status(mcomm *c, int n)

   mfile  *m;

   struct tm *t;

-  cprintf(0,c,"version  : %s\n", PACKAGE_VERSION);

+  cprintf(0,c,"version: %s\n", PACKAGE_VERSION);

   if(moption.chroot){

-    cprintf(0, c, "chroot   : %s/\n", moption.real_dir);

+    cprintf(0, c, "chroot : %s/\n", moption.real_dir);

   }else{

-    cprintf(0, c, "basedir  : %s/\n", moption.base_dir);

+    cprintf(0, c, "basedir: %s/\n", moption.base_dir);

   }

   count = 0;

   for(m=mftop[0];m;m=m->next){

     count++;

   }

-  cprintf(0,c,"send file: %d\n", count);

+  cprintf(0,c,"send op: %d\n", count);

   for(m=mftop[0];m;m=m->next){

     uint32_t snow = m->seqnonow;

     uint32_t smax = m->seqnomax;

     if(snow > smax){

       snow = smax;

     }

-    cprintf(0, c, "  %s %s %s (%u:%u/%u)\n", 

-      OPCODE(m->mdata.head.opcode), 

-      SSTATE(m->mdata.head.nstate), 

-      m->fn, 

-      m->markcount, snow, smax); 

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

+      cprintf(0, c, "  (ack) %s %s %s (%u:%u/%u)\n", 

+        OPCODE(m->mdata.head.opcode), 

+        RSTATE(m->mdata.head.nstate), 

+        m->fn, 

+        m->markcount, snow, smax); 

+    }else{

+      cprintf(0, c, "  (req) %s %s %s (%u:%u/%u)\n", 

+        OPCODE(m->mdata.head.opcode), 

+        SSTATE(m->mdata.head.nstate), 

+        m->fn, 

+        m->markcount, snow, smax); 

+    }

   }

   count = 0;

   for(m=mftop[1];m;m=m->next)

     count++;

-  cprintf(0, c, "recv file: %d\n", count);

+  cprintf(0, c, "recv op: %d\n", count);

   for(m=mftop[1];m;m=m->next){

     t = localtime(&(m->lastrecv.tv_sec));

     cprintf(0, c, "  %s %s %02d:%02d:%02d %s (%d/%d) mark=%d\n",

@@ -294,7 +294,7 @@ static void mrecv_ack_dsync(mdata *data, struct sockaddr_in *addr)

   mhost   *t;

   mfile   *m;

-  lprintf(0, "%s:\n", __func__);

+  lprintf(9, "%s: rid=%d %s\n", __func__, data->head.reqid, RSTATE(data->head.nstate));

   mrecv_ack_search(&t, &m, data, addr);

   if(data->head.nstate == MAKUO_RECVSTATE_CLOSE){

     mkreq(data, addr, MAKUO_SENDSTATE_LAST);

@@ -319,7 +319,7 @@ static void mrecv_ack_del(mdata *data, struct sockaddr_in *addr)

   uint32_t err;

   uint16_t len;

-  lprintf(0, "%s: %s\n", __func__, RSTATE(data->head.nstate));

+  lprintf(9, "%s: rid=%d %s\n", __func__, data->head.reqid, RSTATE(data->head.nstate));

   mrecv_ack_search(&t, &m, data, addr);

   if(!t || !m){

     return;

@@ -333,10 +333,7 @@ static void mrecv_ack_del(mdata *data, struct sockaddr_in *addr)

   *s = data->head.nstate;

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

-    m->initstate = 1;

-    m->sendwait  = 0;

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

-    *s = data->head.nstate;

+    mrecv_mfdel(m);

     return;

   }

@@ -347,9 +344,10 @@ static void mrecv_ack_del(mdata *data, struct sockaddr_in *addr)

     return;

   }

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

+  if(m->mdata.head.nstate == MAKUO_SENDSTATE_OPEN){

     m->initstate = 1;

     m->sendwait  = 0;

+    m->mdata.head.nstate = MAKUO_SENDSTATE_CLOSE;

     if(data->head.nstate == MAKUO_RECVSTATE_DELETEOK){

       err = 0;

       len = strlen(m->fn);

@@ -1021,9 +1019,13 @@ static void mrecv_req_md5(mdata *data, struct sockaddr_in *addr)

   }

 }

-static void dsync_write(int fd, char *base, uint8_t state)

+static void dsync_write(int fd, char *base, uint8_t sta, uint16_t len, uint32_t mod)

 {

-  uint16_t len = strlen(base);

+  int r;

+  size_t s;

+  fd_set wfds;

+  char buff[PATH_MAX + sizeof(sta) +  sizeof(mod) +  sizeof(len)];

+  char *p = buff;

   if(!loop_flag){

     return;

@@ -1035,14 +1037,45 @@ static void dsync_write(int fd, char *base, uint8_t state)

     base += 2;

     len  -= 2;

   }

-  write(fd, &state, sizeof(state));

-  write(fd, &len, sizeof(len));

-  write(fd, base, len);

+  while(*base == '/'){

+    base++;

+    len--;

+  }

+  *(uint8_t  *)p = sta; 

+  p += sizeof(sta);

+  *(uint32_t *)p = mod; 

+  p += sizeof(mod);

+  *(uint16_t *)p = len; 

+  p += sizeof(len);

+  memcpy(p, base, len);

+

+  p = buff;

+  s = sizeof(sta) + sizeof(mod) + sizeof(len) + len;

+  while(s){

+    FD_ZERO(&wfds);

+    FD_SET(fd,&wfds);

+    if(select(1024, NULL, &wfds, NULL, NULL) < 0){

+      if(!loop_flag){

+        return;

+      }

+      continue;

+    }

+    if(FD_ISSET(fd,&wfds)){

+      r = write(fd, p, s);

+      if(r == -1){

+        return;

+      }else{

+        s -= r;

+        p += r;

+      }

+    }

+  }

 }

 static void dsync_scan(int fd, char *base, int recurs)

 {

   DIR *d;

+  uint16_t len;

   struct stat st;

   struct dirent *dent;

   char path[PATH_MAX];

@@ -1050,21 +1083,22 @@ static void dsync_scan(int fd, char *base, int recurs)

   if(!loop_flag){

     return;

   }

-  if(lstat(base,&st) == -1){

-    dsync_write(fd, base, MAKUO_SENDSTATE_ERROR);

+  len = strlen(base);

+  if(lstat(base, &st) == -1){

+    dsync_write(fd, base, MAKUO_SENDSTATE_ERROR, len, st.st_mode);

     return;

   }

   if(S_ISLNK(st.st_mode)){

-    dsync_write(fd, base, MAKUO_SENDSTATE_STAT);

+    dsync_write(fd, base, MAKUO_SENDSTATE_STAT, len, st.st_mode);

     return;

   }

   if(!S_ISDIR(st.st_mode)){

-    dsync_write(fd, base, MAKUO_SENDSTATE_STAT);

+    dsync_write(fd, base, MAKUO_SENDSTATE_STAT, len, st.st_mode);

     return;

   }

   d = opendir(base);

   if(!d){

-    dsync_write(fd, base, MAKUO_SENDSTATE_ERROR);

+    dsync_write(fd, base, MAKUO_SENDSTATE_ERROR, len, st.st_mode);

   }else{

     while(dent=readdir(d)){

       if(!loop_flag)

@@ -1077,11 +1111,13 @@ static void dsync_scan(int fd, char *base, int recurs)

       if(recurs){

         dsync_scan(fd, path, recurs);

       }else{

-        dsync_write(fd, path, MAKUO_SENDSTATE_STAT);

+        len = strlen(path);

+        dsync_write(fd, path, MAKUO_SENDSTATE_STAT, len, st.st_mode);

       }

     }

     closedir(d);

-    dsync_write(fd, base, MAKUO_SENDSTATE_STAT);

+    len = strlen(base);

+    dsync_write(fd, base, MAKUO_SENDSTATE_STAT, len, st.st_mode);

   }

 }

@@ -1198,23 +1234,68 @@ static void mrecv_req_dsync(mdata *data, struct sockaddr_in *addr)

 /*

  *  del

  */

-static void mrecv_req_del_stat(mdata *data, struct sockaddr_in *addr)

+static void mrecv_req_del_open(mdata *data, struct sockaddr_in *addr)

 {

   uint16_t len;

+  uint32_t mod;

+  char path[PATH_MAX];

   char *hn = "unknown host";

   mhost *t = member_get(addr);

   mfile *a = mkack(data, addr, MAKUO_RECVSTATE_DELETENG);

+  mfile *m = NULL;

+  mcomm *c = NULL;

+  char  *p = NULL;

   lprintf(9, "%s:\n", __func__);

+  if(!a){

+    lprintf(0, "%s: arror ack can't create\n", __func__);

+    return;

+  }

+  for(m=mftop[0];m;m=m->next){

+    if((m->comm != NULL) && (m->mdata.head.reqid == data->head.seqno)){

+      c = m->comm;

+      break;

+    }

+  }

+  if(!m){

+    return;

+  }

   if(t){

     hn = t->hostname;

   }

   data->p = data->data;

+  mod = ntohl(*(uint32_t *)(data->p));

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

   len = ntohs(*(uint16_t *)(data->p));

   data->p += sizeof(uint16_t);

   memcpy(a->fn, data->p, len);

   a->fn[len] = 0;

   lprintf(9, "%s: fn=%s\n", __func__, a->fn);

+  

+  strcpy(path, a->fn);

+  if(mfnmatch(path, c->exclude)){

+    return;

+  }

+  if(S_ISDIR(mod)){

+    strcat(path, "/");

+    if(mfnmatch(path, c->exclude)){

+      return;

+    }

+  }

+  for(p=dirname(path);*p == '/';p++);

+  if(*p == 0){

+    return;

+  }

+  while(strcmp(p, ".")){

+    if(mfnmatch(p, c->exclude)){

+      return;

+    }

+    strcat(p, "/");

+    if(mfnmatch(p, c->exclude)){

+      return;

+    }

+    p = dirname(p);

+  }

   if(lstat(a->fn, &(a->fs)) == -1 && errno == ENOENT){

     a->mdata.head.nstate = MAKUO_RECVSTATE_DELETEOK;

     lprintf(1, "%s: delete %s:%s\n", __func__, hn, a->fn);

@@ -1286,10 +1367,9 @@ static void mrecv_req_del_close(mdata *data, struct sockaddr_in *addr)

 static void mrecv_req_del(mdata *data, struct sockaddr_in *addr)

 {

-  lprintf(9, "%s:\n", __func__);

   switch(data->head.nstate){

-    case MAKUO_SENDSTATE_STAT:  /* 存在確認 */

-      mrecv_req_del_stat(data, addr);

+    case MAKUO_SENDSTATE_OPEN:  /* 存在確認 */

+      mrecv_req_del_open(data, addr);

       break;

     case MAKUO_SENDSTATE_DATA:  /* 結果通知 */

       mrecv_req_del_data(data, addr);

@@ -1304,22 +1384,22 @@ static void mrecv_req(mdata *data, struct sockaddr_in *addr)

 {

   switch(data->head.opcode){

     case MAKUO_OP_PING:

-      mrecv_req_ping(data, addr);

+      mrecv_req_ping(data,  addr);

       break;

     case MAKUO_OP_EXIT:

-      mrecv_req_exit(data, addr);

+      mrecv_req_exit(data,  addr);

       break;

     case MAKUO_OP_SEND:

-      mrecv_req_send(data, addr);

+      mrecv_req_send(data,  addr);

       break;

     case MAKUO_OP_MD5:

-      mrecv_req_md5(data, addr);

+      mrecv_req_md5(data,   addr);

       break;

     case MAKUO_OP_DSYNC:

       mrecv_req_dsync(data, addr);

       break;

     case MAKUO_OP_DEL:

-      mrecv_req_del(data, addr);

+      mrecv_req_del(data,   addr);

       break;

     default:

       mkack(data, addr, MAKUO_RECVSTATE_IGNORE);

@@ -104,8 +104,18 @@ static void msend_retry(mfile *m)

     m->retrycnt = MAKUO_SEND_RETRYCNT;

     return;

   }

-  lprintf(2, "%s: send retry count=%02d rid=%06d state=%s %s\n", __func__,

-    m->retrycnt, m->mdata.head.reqid, SSTATE(m->mdata.head.nstate), m->fn);

+  if(m->mdata.head.opcode == MAKUO_OP_DSYNC){

+    if(m->mdata.head.nstate == MAKUO_SENDSTATE_CLOSE){

+      return;

+    }

+  }

+  lprintf(2, "%s: send retry count=%02d rid=%06d op=%s state=%s %s\n", 

+    __func__,

+    m->retrycnt, 

+    m->mdata.head.reqid, 

+    OPCODE(m->mdata.head.opcode), 

+    SSTATE(m->mdata.head.nstate), 

+    m->fn);

   for(t=members;t;t=t->next){

     r = get_hoststate(t, m);

     if(!r){

@@ -115,19 +125,22 @@ static void msend_retry(mfile *m)

     switch(moption.loglevel){

       case 3:

         if(*r == MAKUO_RECVSTATE_NONE){

-          lprintf(0, "%s:   %s %s(%s)\n", __func__, RSTATE(*r), inet_ntoa(t->ad), t->hostname);

+          lprintf(0, "%s:   %s %s(%s)\n", 

+            __func__, 

+           RSTATE(*r), 

+           inet_ntoa(t->ad), 

+           t->hostname);

         }

         break;

       default:

-        lprintf(4, "%s:   %s %s(%s)\n", __func__, RSTATE(*r), inet_ntoa(t->ad), t->hostname);

+        lprintf(4, "%s:   %s %s(%s)\n", 

+          __func__, 

+          RSTATE(*r), 

+          inet_ntoa(t->ad), 

+          t->hostname);

         break;

     }

   }

-  if(m->mdata.head.opcode == MAKUO_OP_DSYNC){

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

-      return;

-    }

-  }

   m->retrycnt--;

 }

@@ -188,6 +201,7 @@ static void msend_ack_dsync(int s, mfile *m)

 static void msend_ack_del(int s, mfile *m)

 {

+  lprintf(9, "%s:\n", __func__);

   msend_shot(s, m);

 }

@@ -769,11 +783,13 @@ static void msend_req_del_mark(int s, mfile *m)

   mkack(&(d->mdata), &(d->addr), MAKUO_RECVSTATE_CLOSE);

 }

-static void msend_req_del_init(int s, mfile *m)

+static void msend_req_del_stat(int s, mfile *m)

 {

   int r;

+  mfile *d;

   uint8_t stat;

   uint16_t len;

+  uint32_t mod;

   lprintf(9, "%s:\n", __func__);

   r = read(m->pipe, &stat, sizeof(stat));

@@ -791,17 +807,25 @@ static void msend_req_del_init(int s, mfile *m)

     return;

   }

+  d = mkreq(&(m->mdata), &(m->addr), MAKUO_SENDSTATE_OPEN);

+  read(m->pipe, &mod, sizeof(mod));

   read(m->pipe, &len, sizeof(len));

-  read(m->pipe, m->fn, len);

-  m->fn[len] = 0;

-  lprintf(9, "%s: fn=%s\n", __func__, m->fn);

-

-  m->mdata.p = m->mdata.data;

-  *(uint16_t *)(m->mdata.p) = htons(len);

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

-  memcpy(m->mdata.p, m->fn, len);

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

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

+  read(m->pipe, d->fn, len);

+  d->fn[len] = 0;

+  d->mdata.p = d->mdata.data;

+  *(uint32_t *)(d->mdata.p) = htonl(mod);

+  d->mdata.p += sizeof(mod);

+  *(uint16_t *)(d->mdata.p) = htons(len);

+  d->mdata.p += sizeof(len);

+  memcpy(d->mdata.p, d->fn, len);

+  d->mdata.head.flags  = m->mdata.head.flags;

+  d->mdata.head.szdata = sizeof(mod) + sizeof(len) + len;

+  d->mdata.head.reqid  = getrid();

+  d->initstate = 1;

+  d->sendwait  = 0;

+  d->dryrun = m->dryrun;

+  d->recurs = m->recurs;

+  lprintf(9, "%s: fn=%s rid=%d\n", __func__, d->fn, d->mdata.head.reqid);

 }

 /*----- del -----*/

@@ -815,13 +839,14 @@ static void msend_req_del(int s, mfile *m)

     msend_mfdel(m);

     return;

   }

+  if(m->mdata.head.nstate == MAKUO_SENDSTATE_STAT){

+    msend_req_del_stat(s, m);

+    return;

+  }

   if(m->initstate){

     m->initstate = 0;

     m->sendwait  = 1;

     ack_clear(m, -1);

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

-      msend_req_del_init(s, m);

-    }

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

       msend_req_del_mark(s, m);

       return;