@@ -11,6 +11,22 @@ int loop_flag   = 1;

 struct timeval curtime;

 BF_KEY EncKey;

+char *opcodestrlist[7]={"PING ",

+                        "EXIT ",

+                        "SEND ",

+                        "MD5  ",

+                        "DSYNC",

+                        "DEL  ",

+                        "UNKNOWN"};

+

+uint8_t opcodenumlist[7]={MAKUO_OP_PING,

+                          MAKUO_OP_EXIT,

+                          MAKUO_OP_SEND,

+                          MAKUO_OP_MD5,

+                          MAKUO_OP_DSYNC,

+                          MAKUO_OP_DEL,

+                          MAKUO_OPCODE_MAX};

+

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

                         "SEND_OPEN",

                         "SEND_DATA",

@@ -18,7 +34,7 @@ char *sstatestrlist[9]={"SEND_STAT",

                         "SEND_CLOSE",

                         "SEND_LAST",

                         "SEND_ERROR",

-                        "SEND_BREAK"

+                        "SEND_BREAK",

                         "SEND_UNKNOWN"};

 uint8_t sstatenumlist[9]={MAKUO_SENDSTATE_STAT,

@@ -39,6 +55,7 @@ char *rstatestrlist[16] = {"RECV_NONE",

                            "RECV_CLOSE",

                            "RECV_IGNORE",

                            "RECV_READONLY",

+                           "RECV_BREAK",

                            "RECV_MD5OK",

                            "RECV_MD5NG",

                            "RECV_OPENERR",

@@ -55,6 +72,7 @@ uint8_t rstatenumlist[16]={MAKUO_RECVSTATE_NONE,

                            MAKUO_RECVSTATE_CLOSE,

                            MAKUO_RECVSTATE_IGNORE,

                            MAKUO_RECVSTATE_READONLY,

+                           MAKUO_RECVSTATE_BREAK,

                            MAKUO_RECVSTATE_MD5OK,

                            MAKUO_RECVSTATE_MD5NG,

                            MAKUO_RECVSTATE_OPENERROR,

@@ -85,6 +103,17 @@ char *RSTATE(uint8_t n)

   return(rstatestrlist[i]);

 }

+char *OPCODE(uint8_t n)

+{

+  int i;

+  for(i=0;opcodenumlist[i] != MAKUO_STATE_MAX;i++){

+    if(opcodenumlist[i] == n){

+      break;

+    }

+  }

+  return(opcodestrlist[i]);

+}

+

 int md5sum(int fd, unsigned char *digest)

 {

   int  rd;

@@ -241,7 +270,8 @@ mfile *mfnew()

   if(m = (mfile *)malloc(sizeof(mfile))){

     memset(m, 0, sizeof(mfile));

     m->mdata.head.vproto = PROTOCOL_VERSION;

-    m->fd = -1;

+    m->fd   = -1;

+    m->pipe = -1;

     m->retrycnt = MAKUO_SEND_RETRYCNT;

     memcpy(&(m->addr), &(moption.maddr), sizeof(m->addr));

   }

@@ -257,8 +287,8 @@ mfile *mfadd(int n)

     }else{

       mfile *l;

       for(l=mftop[n];l->next;l=l->next);

-      l->next = (void *)m;

-      m->prev = (void *)l;

+      l->next = m;

+      m->prev = l;

       m->next = NULL;

     }

   }

@@ -704,7 +734,6 @@ int mremove(char *base, char *name)

     strcpy(path,name);

   }else{

     sprintf(path, "%s/%s", base, name);

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

   }

   if(is_dir(path)){

     if(d = opendir(path)){

@@ -195,11 +195,6 @@ int ismsend(int s, mfile *m)

       return(0);

     }

   }

-  if(m->senddelay){

-    if(!mtimeout(&(m->lastsend), m->senddelay)){

-      return(1);

-    }

-  }

   r = ack_check(m, MAKUO_RECVSTATE_NONE);

   if(r == -1){

     m->mdata.head.seqno  = 0;

@@ -47,6 +47,7 @@

 #define MAKUO_HOSTNAME_MAX 255

 #define MAKUO_PARALLEL_MAX   8

 #define MAKUO_STATE_MAX    255

+#define MAKUO_OPCODE_MAX   255

 /*----- default -----*/

 #define MAKUO_LOCAL_ADDR  "127.0.0.1"

@@ -56,7 +57,6 @@

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

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

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

-#define MAKUO_SEND_DELAYSTP 0      /* 送出遅延時間の増分(ms)                       */

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

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

 #define MAKUO_RECV_GCWAIT   180000 /* 消し損ねたオブジェクトを開放する待ち時間(ms) */

@@ -70,10 +70,12 @@

 #define MAKUO_OP_DEL   5

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

-#define MAKUO_FLAG_ACK   1

-#define MAKUO_FLAG_CRYPT 2

-#define MAKUO_FLAG_WAIT  4

-#define MAKUO_FLAG_FMARK 8

+#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

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

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

@@ -94,6 +96,7 @@

 #define MAKUO_RECVSTATE_CLOSE      5

 #define MAKUO_RECVSTATE_IGNORE     6

 #define MAKUO_RECVSTATE_READONLY   7

+#define MAKUO_RECVSTATE_BREAK      8

 #define MAKUO_RECVSTATE_MD5OK      10

 #define MAKUO_RECVSTATE_MD5NG      11

 #define MAKUO_RECVSTATE_DELETEOK   12

@@ -181,13 +184,7 @@ typedef struct

   excludeitem *exclude;

 } mcomm;

-typedef struct

-{

-  DIR  *d;

-  void *m;

-} mdelete;

-

-typedef struct

+typedef struct mfile

 {

   int  fd;

   char fn[PATH_MAX];

@@ -199,7 +196,6 @@ typedef struct

   uint32_t retrycnt;

   uint32_t sendwait;

   uint32_t lickflag;

-  uint32_t senddelay;

   uint32_t initstate;

   uint32_t recvcount;

   uint32_t markdelta;

@@ -212,15 +208,15 @@ typedef struct

   int pid;

   int pipe;

   mdata mdata;

-  mdelete del;

   mcomm *comm;

   uint32_t *mark;

-  void  *prev;

-  void  *next;

   struct stat fs;

   struct sockaddr_in addr;

   struct timeval lastsend;

   struct timeval lastrecv;

+  struct mfile *prev;

+  struct mfile *next;

+  struct mfile *link;

 } mfile;

 typedef struct

@@ -521,8 +521,9 @@ int mexec_dsync(mcomm *c, int n)

     }

   }

-  while(optind < c->argc[n])

+  while(optind < c->argc[n]){

     fn = c->parse[n][optind++];

+  }

   /*----- help -----*/

   if(c->argc[n]<2){

@@ -540,21 +541,28 @@ int mexec_dsync(mcomm *c, int n)

     return(0);

 	}

-  sprintf(m->fn,".");

+  strcpy(m->fn, ".");

   if(fn){

     if(*fn != '/'){

 	    strcat(m->fn, "/");

     }

 	  strcat(m->fn, fn);

   }

+  

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

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

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

 	m->mdata.head.opcode = MAKUO_OP_DSYNC;

   m->mdata.head.nstate = MAKUO_SENDSTATE_OPEN;

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

-	m->comm      = c;

-  m->dryrun    = dryrun;

-  m->recurs    = recurs;

+	m->comm = c;

+  if(dryrun){

+    m->dryrun = 1;

+    m->mdata.head.flags |= MAKUO_FLAG_DRYRUN;

+  }

+  if(recurs){

+    m->recurs = 1;

+    m->mdata.head.flags |= MAKUO_FLAG_RECURS;

+  }

   m->initstate = 1;

   /*----- send to address set -----*/

@@ -707,7 +715,11 @@ int mexec_status(mcomm *c, int n)

     if(snow > smax){

       snow = smax;

     }

-    cprintf(0, c, "  %s %s (%u:%u/%u)\n", SSTATE(m->mdata.head.nstate), m->fn, m->markcount, 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); 

   }

   count = 0;

@@ -716,8 +728,13 @@ int mexec_status(mcomm *c, int n)

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

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

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

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

-      RSTATE(m->mdata.head.nstate), t->tm_hour, t->tm_min, t->tm_sec, m->fn, m->recvcount, m->seqnomax, m->markcount); 

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

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

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

+      t->tm_hour, t->tm_min, t->tm_sec, 

+      m->fn, 

+      m->recvcount, m->seqnomax, 

+      m->markcount); 

   }

   return(0);

 }

@@ -312,26 +312,65 @@ static void mrecv_ack_dsync(mdata *data, struct sockaddr_in *addr)

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

 {

-  uint8_t *s;

-  mhost   *t;

-  mfile   *m;

+  uint8_t   *s;

+  mhost     *t;

+  mfile     *m;

+  uint32_t err;

+  uint16_t len;

+

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

   if(!t || !m){

     return;

   }

   mtimeget(&m->lastrecv);

-  s = get_hoststate(t,m);

-  if(!s){

-    lprintf(0, "%s: not allocate state area\n", __func__);

+

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

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

+    s = get_hoststate(t,m);

+    if(!s){

+      lprintf(0, "%s: not allocate state area\n", __func__);

+      return;

+    }

+    *s = data->head.nstate;

     return;

   }

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

-    lprintf(0,"%s: delete OK %s\n", __func__, m->fn);

+

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

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

+    return;

   }

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

-    lprintf(0,"%s: delete NG %s\n", __func__, m->fn);

+

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

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

+      s = get_hoststate(t,m);

+      if(!s){

+        lprintf(0, "%s: not allocate state area\n", __func__);

+        return;

+      }

+      *s = data->head.nstate;

+    }else{

+      err = 0;

+      len = strlen(m->fn);

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

+      if(m->dryrun){

+        lprintf(1, "%s: (dryrun) delete %s\n", __func__, m->fn);

+      }else{

+        if(!mremove(NULL,m->fn)){

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

+        }else{

+          err = errno;

+          lprintf(0, "%s: delete error %s (%s)\n", __func__, m->fn, strerror(errno));

+        }

+      }

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

+      *(uint32_t *)(m->mdata.p) = htonl(err);

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

+      *(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(err) +  sizeof(len) + len; 

+    }

   }

-  *s = data->head.nstate;

 }

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

@@ -380,7 +419,7 @@ static void mrecv_req_ping(mdata *data, struct sockaddr_in *addr)

   mfile *a;

   char buff[MAKUO_HOSTNAME_MAX + 1];

   member_add(&addr->sin_addr, data);

-  a = mkack(data,addr, MAKUO_RECVSTATE_NONE);

+  a = mkack(data, addr, MAKUO_RECVSTATE_NONE);

   if(gethostname(buff, sizeof(buff)) == -1){

     buff[0] = 0;

   }

@@ -984,22 +1023,31 @@ static void dsync_write(int fd, char *base, uint8_t state)

 {

   uint16_t len = strlen(base);

-  base += 2;

-  len  -= 2;

-  if(!len){

+  if(!loop_flag){

+    return;

+  }

+  if(!strcmp(base, ".")){

     return;

   }

+  if(!memcmp(base, "./", 2)){

+    base += 2;

+    len  -= 2;

+  }

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

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

   write(fd, base, len);

 }

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

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

 {

   DIR *d;

   struct stat st;

   struct dirent *dent;

   char path[PATH_MAX];

+

+  if(!loop_flag){

+    return;

+  }

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

     dsync_write(fd, base, MAKUO_SENDSTATE_ERROR);

     return;

@@ -1017,12 +1065,18 @@ static void dsync_scan(int fd, char *base)

     dsync_write(fd, base, MAKUO_SENDSTATE_ERROR);

   }else{

     while(dent=readdir(d)){

+      if(!loop_flag)

+        break;

       if(!strcmp(dent->d_name, "."))

         continue;

       if(!strcmp(dent->d_name, ".."))

         continue;

       sprintf(path, "%s/%s", base, dent->d_name);

-      dsync_scan(fd, path);

+      if(recurs){

+        dsync_scan(fd, path, recurs);

+      }else{

+        dsync_write(fd, path, MAKUO_SENDSTATE_STAT);

+      }

     }

     closedir(d);

     dsync_write(fd, base, MAKUO_SENDSTATE_STAT);

@@ -1036,68 +1090,95 @@ static void mrecv_req_dsync_open(mfile *m, mdata *data, struct sockaddr_in *addr

   mfile *d;

   char path[PATH_MAX];

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

   mkack(data, addr, MAKUO_RECVSTATE_OPEN);

-  if(!m){

-    m = mfadd(1);

-    m->mdata.head.opcode = data->head.opcode;

-    m->mdata.head.reqid  = data->head.reqid;

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

-    memcpy(&(m->addr), addr, sizeof(m->addr));

-    if(data->head.szdata){

-      memcpy(m->fn, data->data, data->head.szdata);

-    }

-    m->fn[data->head.szdata] = 0;

-

-    /* 走査 */

-    d = mfins(0);

-    d->del.m = (void *)m;

-    m->del.m = (void *)d;

-    d->mdata.head.opcode = MAKUO_OP_DEL;

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

-    d->mdata.head.seqno  = data->head.reqid;

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

-    memcpy(&(d->addr), addr, sizeof(d->addr));

-    memcpy(&(d->fn), data->data, data->head.szdata);

-    d->fn[data->head.szdata] = 0;

-

-    /* fork */

-    pipe(p);

-    pid = fork();

-    if(pid == -1){

-      close(p[0]);

-      close(p[1]);

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

-      return;

-    }

-    if(pid){

-      /* parent */

-      d->pid  = pid;

-      d->pipe = p[0];

-      close(p[1]); /* write close */

-    }else{

-      /* child */

-      close(p[0]); /* read close */

-      dsync_scan(p[1], d->fn);

-      close(p[1]);

-      _exit(0);

-    }  

+  if(m){

+    return;

   }

+  m = mfadd(1);

+  m->mdata.head.opcode = data->head.opcode;

+  m->mdata.head.reqid  = data->head.reqid;

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

+  memcpy(&(m->addr), addr, sizeof(m->addr));

+  if(data->head.szdata){

+    memcpy(m->fn, data->data, data->head.szdata);

+  }

+  m->fn[data->head.szdata] = 0;

+

+  /* 走査 */

+  d = mfins(0);

+  d->link = (void *)m;

+  m->link = (void *)d;

+  d->mdata.head.opcode = MAKUO_OP_DEL;

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

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

+  d->mdata.head.seqno  = data->head.reqid;

+  d->mdata.head.nstate = MAKUO_SENDSTATE_STAT;

+  memcpy(&(d->addr), addr, sizeof(d->addr));

+  memcpy(&(d->fn), data->data, data->head.szdata);

+  d->fn[data->head.szdata] = 0;

+  if(d->mdata.head.flags & MAKUO_FLAG_RECURS){

+    d->recurs = 1;

+  }

+  if(d->mdata.head.flags & MAKUO_FLAG_DRYRUN){

+    d->dryrun = 1;

+  }

+

+  /* fork */

+  pipe(p);

+  pid = fork();

+  if(pid == -1){

+    lprintf(0, "%s: fork error (%s)\n", __func__, strerror(errno));

+    close(p[0]);

+    close(p[1]);

+    return;

+  }

+  if(pid){

+    /* parent */

+    d->pid  = pid;

+    d->pipe = p[0];

+    close(p[1]); /* write close */

+  }else{

+    /* child */

+    close(p[0]); /* read close */

+    dsync_scan(p[1], d->fn, d->recurs);

+    close(p[1]);

+    _exit(0);

+  }  

 }

 static void mrecv_req_dsync_last(mfile *m, mdata *data, struct sockaddr_in *addr)

 {

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

-  mfile *d = m->del.m;

-  d->mdata.head.nstate = MAKUO_SENDSTATE_LAST;

-  d->sendwait = 0;

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

+  if(!m){

+    return;

+  }

+  if(m->link){

+    m->link->mdata.head.nstate = MAKUO_SENDSTATE_LAST;

+    m->link->sendwait = 0;

+  }

   mrecv_mfdel(m); 

 }

+static void mrecv_req_dsync_break(mfile *m, mdata *data, struct sockaddr_in *addr)

+{

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

+  if(m){

+    if(m->link){

+      m->link->mdata.head.nstate = MAKUO_SENDSTATE_BREAK;

+      m->link->sendwait = 0;

+    }

+    mrecv_mfdel(m);

+  }

+  mkack(data, addr, MAKUO_RECVSTATE_BREAK);

+}

+

 /*

  *  dsync

  */

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

 {

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

   mfile *m = mrecv_req_search(data, addr);

   switch(data->head.nstate){

     case MAKUO_SENDSTATE_OPEN:

@@ -1106,39 +1187,109 @@ static void mrecv_req_dsync(mdata *data, struct sockaddr_in *addr)

     case MAKUO_SENDSTATE_LAST:

       mrecv_req_dsync_last(m, data, addr);

       break;

+    case MAKUO_SENDSTATE_BREAK:

+      mrecv_req_dsync_break(m, data, addr);

+      break;

   }

 }

 /*

  *  del

  */

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

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

 {

-  uint8_t stat;

   uint16_t len;

-

+  char *hn = "unknown host";

   mhost *t = member_get(addr);

-  if(!t){

-    return;

-  }

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

+  if(t){

+    hn = t->hostname;

+  }

   data->p = data->data;

-  stat = *(uint8_t *)(data->p);

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

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

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

   data->p += sizeof(uint16_t);

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

   a->fn[len] = 0;

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

-    mfile *m;

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

-      if(m->mdata.head.reqid == data->head.seqno){

-        break;

-      } 

-    }

     a->mdata.head.nstate = MAKUO_RECVSTATE_DELETEOK;

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

-    cprintf(0, m->comm, "delete %s:%s\n", t->hostname, a->fn);

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

+  }

+}

+

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

+{

+  uint32_t err;

+  uint16_t len;

+  char *hn = "unknown host";

+  mhost *t = member_get(addr);

+  mcomm *c = NULL;

+  mfile *m = mrecv_req_search(data, addr);

+  mfile *a = mkack(data, addr, MAKUO_RECVSTATE_OPEN);

+

+  if(m){

+    mtimeget(&(m->lastrecv));

+    return;

+  }

+  if(t){

+    hn = t->hostname;

+  }

+  m = mfadd(1);

+  m->mdata.head.opcode = data->head.opcode;

+  m->mdata.head.reqid  = data->head.reqid;

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

+  memcpy(&(m->addr), addr, sizeof(m->addr));

+  mtimeget(&(m->lastrecv));

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

+    m->dryrun = 1;

+  }

+  data->p = data->data;

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

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

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

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

+  memcpy(m->fn, data->p, len);

+  m->fn[len] = 0;

+

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

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

+      c = a->comm;

+      break;

+    } 

+  }

+  if(m->dryrun){

+    cprintf(0, c, "(dryrun) delete %s:%s\n", hn, m->fn);

+  }else{

+    if(err){

+      cprintf(0, c,  "(%s) delete error %s:%s\n", strerror(err), hn, m->fn);

+    }else{

+      cprintf(0, c,  "delete %s:%s\n", hn, m->fn);

+    }

+  }

+}

+

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

+{

+  mfile *m = mrecv_req_search(data, addr);

+  mfile *a = mkack(data, addr, MAKUO_RECVSTATE_CLOSE);

+  if(!m){

+    return;

+  }

+  mrecv_mfdel(m);

+}

+

+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);

+      break;

+    case MAKUO_SENDSTATE_DATA:  /* 結果通知 */

+      mrecv_req_del_data(data, addr);

+      break;

+    case MAKUO_SENDSTATE_CLOSE: /* 結果開放 */

+      mrecv_req_del_close(data, addr);

+      break;

   }

 }

@@ -1163,9 +1314,9 @@ static void mrecv_req(mdata *data, struct sockaddr_in *addr)

     case MAKUO_OP_DEL:

       mrecv_req_del(data, addr);

       break;

-    /*----- 機能追加はこの上 -----*/

     default:

       mkack(data, addr, MAKUO_RECVSTATE_IGNORE);

       break;

   }

 }

+

@@ -15,13 +15,23 @@ static void msend_req(int s, mfile *m);

 static mfile *msend_mfdel(mfile *m)

 {

   mfile *r;

-  if(!m)

+  if(!m){

     return(NULL);

+  }

   r = m->next;

-  if(m->fd != -1)

-    close(m->fd);   

-  if(m->mark)

+  if(m->fd != -1){

+    close(m->fd);

+  }

+  if(m->pipe != -1){

+    close(m->pipe);

+  }

+  if(m->pid){

+    kill(m->pid, SIGTERM);

+    waitpid(m->pid, NULL, 0);

+  }

+  if(m->mark){

     free(m->mark);

+  }

   clr_hoststate(m);

   mfdel(m);

   return(r);

@@ -74,8 +84,8 @@ static int msend_packet(int s, mdata *data, struct sockaddr_in *addr)

         if(errno == EINTR){

           continue;

         }else{

-          lprintf(0,"%s: send error errno=%d sock=%d op=%d rid=%d state=%s size=%d seqno=%d\n", __func__,

-            errno, s, data->head.opcode, data->head.reqid, SSTATE(data->head.nstate), sizeof(mhead) + szdata, data->head.seqno);

+          lprintf(0,"%s: send error (%s) sock=%d op=%d rid=%d state=%s size=%d seqno=%d\n", __func__,

+            strerror(errno), s, data->head.opcode, data->head.reqid, SSTATE(data->head.nstate), sizeof(mhead) + szdata, data->head.seqno);

           return(-1);

         }

       }

@@ -657,6 +667,7 @@ static void msend_req_md5(int s, mfile *m)

 static void msend_req_dsync_open_init(int s, mfile *m)

 {

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

   m->sendwait  = 1;

   m->initstate = 0;

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

@@ -664,6 +675,7 @@ static void msend_req_dsync_open_init(int s, mfile *m)

 static void msend_req_dsync_open(int s, mfile *m)

 {

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

   if(m->initstate){

     msend_req_dsync_open_init(s, m);

     return;

@@ -678,6 +690,7 @@ static void msend_req_dsync_open(int s, mfile *m)

 static void msend_req_dsync_close_init(int s, mfile *m)

 {

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

   m->sendwait  = 1;

   m->initstate = 0;

   ack_clear(m, MAKUO_RECVSTATE_OPEN);

@@ -685,6 +698,7 @@ static void msend_req_dsync_close_init(int s, mfile *m)

 static void msend_req_dsync_close(int s, mfile *m)

 {

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

   if(m->initstate){

     msend_req_dsync_close_init(s, m);

     return;

@@ -696,9 +710,42 @@ static void msend_req_dsync_close(int s, mfile *m)

   msend_mfdel(m);

 }

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

+{

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

+  m->sendwait  = 1;

+  m->initstate = 0;

+  ack_clear(m, -1);

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

+}

+

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

+{

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

+  if(m->initstate){

+    msend_req_dsync_break_init(s, m);

+    return;

+  }

+  if(m->sendwait){

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

+    return;

+  }

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

+  msend_mfdel(m);

+}

+

 /*----- dsync -----*/

 static void msend_req_dsync(int s, mfile *m)

 {

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

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

+    if(!m->comm){

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

+        m->initstate = 1;

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

+      }

+    }

+  }

   switch(m->mdata.head.nstate){

     case MAKUO_SENDSTATE_OPEN:

       msend_req_dsync_open(s, m);

@@ -706,16 +753,19 @@ static void msend_req_dsync(int s, mfile *m)

     case MAKUO_SENDSTATE_CLOSE:

       msend_req_dsync_close(s, m);

       break;

+    case MAKUO_SENDSTATE_BREAK:

+      msend_req_dsync_break(s, m);

+      break;

     case MAKUO_SENDSTATE_LAST:

       msend_shot(s, m);

       break;

   }

 }

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

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

 {

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

-  mfile *d = m->del.m; /* dsync object */

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

+  mfile *d = m->link; /* dsync object */

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

   ack_clear(m, -1);

 }

@@ -723,18 +773,10 @@ static void msend_req_del_close(int s, mfile *m)

 static void msend_req_del_init(int s, mfile *m)

 {

   int r;

-  uint16_t len;

   uint8_t stat;

+  uint16_t len;

-  if(m->pipe == -1){

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

-    msend_req_del_close(s, m);

-    m->sendwait  = 1;

-    m->initstate = 0;

-    ack_clear(m, -1);

-    return;

-  }

-

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

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

   if(r <= 0){

     /* eof */

@@ -743,7 +785,7 @@ static void msend_req_del_init(int s, mfile *m)

       m->pipe = -1;

       m->pid  =  0;

     }

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

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

     m->sendwait  = 1;

     m->initstate = 0;

     ack_clear(m, -1);

@@ -753,14 +795,13 @@ static void msend_req_del_init(int s, mfile *m)

   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;

-  *(uint8_t  *)(m->mdata.p) = stat;

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

   *(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(stat) + sizeof(len) + len; 

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

   m->sendwait  = 1;

   m->initstate = 0;

   ack_clear(m, -1);

@@ -770,6 +811,11 @@ static void msend_req_del_init(int s, mfile *m)

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

 static void msend_req_del(int s, mfile *m)

 {

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

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

+    msend_mfdel(m);

+    return;

+  }

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

     msend_mfdel(m);

     return;

@@ -779,8 +825,8 @@ static void msend_req_del(int s, mfile *m)

     return;

   }

   if(m->sendwait){

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

-      msend_req_del_close(s, m);