/*
 * common.c
 * Copyright (C) 2008-2012 KLab Inc.
 */
#include "makuosan.h"

mopt moption;
mfile *mftop[2]  = {NULL,NULL};
mfile *mfreeobj  = NULL;
mhost *members   = NULL;
int send_rate    = 0;
int view_rate    = 0;
time_t send_time = 0;
struct timeval curtime;
struct timeval lastpong;
BF_KEY EncKey;
volatile sig_atomic_t log_level = 0;
volatile sig_atomic_t loop_flag = 1;

char *yesno(int n)
{
  static char *YES="yes";
  static char *NO="no";
  if(n){
    return(YES);
  }
  return(NO);
}

/*
 *  タイムアウト時間が経過しているかどうかを判断する
 *   - 現在時刻がtfからmsec[ms]経過していれば1を返す
 *   - 経過していなければ0を返す
 */
int mtimeout(struct timeval *tf, uint32_t msec)
{
  struct timeval tv;
  struct timeval tr;
  
  if((tf->tv_sec == 0) && (tf->tv_usec == 0)){
    return(0);
  }
  tv.tv_sec  = msec / 1000;
  tv.tv_usec = (msec % 1000) * 1000;
  timeradd(tf, &tv, &tr);
  return(timercmp(&tr, &curtime, <));
}

/*
 *  現在時刻を取得する
 *  （といってもcurtimeをコピーするだけだけど）
 */
int mtimeget(struct timeval *tv)
{
  memcpy(tv, &curtime, sizeof(curtime));
  return(0);
}

/*
 *  ファイル名がexcludeリストにマッチするかどうかを調べる
 *   - マッチした場合はそのexcludeitem構造体のポインタを返す
 *   - マッチしない場合はNULLを返す
 */
excludeitem *mfnmatch(char *str, excludeitem *exclude)
{
  char *p;
  excludeitem *e;
  for(e=exclude;e;e=e->next){
    p=str;
    while(*p){
      if(strlen(p) < strlen(e->pattern)){
        break;
      }
      if(!fnmatch(e->pattern, p, FNM_PATHNAME)){
        return(e);
      }
      while(*p){
        if(*(p++) == '/'){
          break;
        }
      }
    }
  }
  return(NULL);
}

int isexclude(char *fn, excludeitem *exclude, int dir)
{
  char path[PATH_MAX];
  if(!strcmp(fn, ".")){
    fn = "";
  }
  if(!memcmp(fn, "./", 2)){
    fn += 2;
  }
  while(*fn == '/'){
    fn++;
  }
  if(dir){
    sprintf(path, "%s/%s/", moption.real_dir, fn);
  }else{
    sprintf(path, "%s/%s" , moption.real_dir, fn);
  }
  if(mfnmatch(path, exclude)){
    return(1);
  }
  return(0);
}

uint32_t getrid()
{
  static uint32_t rid=0;
  return(rid++);
}

int workend(mcomm *c)
{
  char *m;
  if(!c){
    return(0);
  }
  if(!c->working){
    return(0);
  }
  if(c->cpid){
    return(0);
  }
  if(moption.commpass && !c->authchk){
    m = "password: \x1b]E";
  }else{
    if(c->logover && strcmp("dsync", c->parse[0][0])){
      if(cprintf(0, c, "[error] Log lost: %d lines\n", c->logover) == 0){
        c->logover = 0;
      }else{
        c->logover--;
      }
    }
    if(c->logfail){
      m = "\n> ";
    }else{
      m = "> ";
    }
  }
  if(cprintf(0, c, m) == 0){
    c->working = 0;
  }else{
    c->logover--;
  }
  return(0);
}

mfile *mfalloc()
{
  mfile *m = mfreeobj;
  if(m){
    mfreeobj = m->next;
  }else{
    m = (mfile *)malloc(sizeof(mfile));
  }
  return(m);
}

void mfree(mfile *m){
  m->prev  = NULL;
  m->next  = mfreeobj;
  mfreeobj = m;
}

void mfdel(mfile *m)
{
  mfile *p;
  mfile *n;
  if(m){
    if((p = (mfile *)m->prev)){
      p->next = m->next;
    }
    if((n = (mfile *)m->next)){
      n->prev = m->prev;
    }
    if(mftop[0] == m){
      mftop[0] = n;
    }
    if(mftop[1] == m){
      mftop[1] = n;
    }
    mfree(m);
  }
}

mfile *mfnew()
{
  mfile *m;
  if((m = mfalloc())){
    memset(m, 0, sizeof(mfile));
    m->mdata.head.maddr  = moption.maddr.sin_addr.s_addr;
    m->mdata.head.mport  = moption.maddr.sin_port;
    m->mdata.head.vproto = PROTOCOL_VERSION;
    m->fd   = -1;
    m->pipe = -1;
    m->retrycnt = MAKUO_SEND_RETRYCNT;
    memcpy(&(m->addr), &(moption.maddr), sizeof(m->addr));
  }
  return(m);
}

mfile *mfadd(int n)
{
  mfile *m;
  if((m = mfnew())){
    if(!mftop[n]){
      mftop[n] =m;
    }else{
      mfile *l;
      for(l=mftop[n];l->next;l=l->next);
      l->next = m;
      m->prev = l;
      m->next = NULL;
    }
  }
  return(m);
}

mfile *mfins(int n)
{
  mfile *m;
  if((m = mfnew())){
    if(mftop[n]){
      mftop[n]->prev = m;
      m->next = mftop[n];
    }
    mftop[n] =m;
  }
  return(m);
}

mhost *member_get(struct in_addr *addr)
{
  mhost *t;
  for(t=members;t;t=t->next){
    if(!memcmp(&t->ad, addr, sizeof(t->ad))){
      return(t);
    }
  }
  return(NULL); 
}

mhost *member_add(struct in_addr *addr, mdata *data)
{
  int f = 0;
  int l = 0;
  mping *p = NULL;
  mhost *t = member_get(addr);

  if(!t){
    f = 1;
    t = malloc(sizeof(mhost));
    if(!t){
      lprintf(0, "%s: out of memory\n", __func__);
      return(NULL);
    }
    memset(t, 0, sizeof(mhost));
    memcpy(&t->ad, addr, sizeof(t->ad));
    if(members){
      members->prev = t;
      t->next = members;
    }
    members = t;
    t->hostname[0] = 0;
  }
  if(data){
    if(data->head.opcode == MAKUO_OP_PING){
      p = (mping *)data->data;
      l = ntohs(p->hostnamelen);
      data->p = p->data;
      memcpy(t->hostname, data->p, l);
      t->hostname[l] = 0;
      data->p += l;
      l = ntohs(p->versionlen);
      memcpy(t->version,  data->p, l);
      t->version[l] = 0;
    }
  }
  if(f){
    lprintf(0, "%s: %s (%s)\n", __func__, inet_ntoa(t->ad), t->hostname);
  }
  mtimeget(&(t->lastrecv));
  return(t);
}

void member_del(mhost *t)
{
  mhost *p;
  mhost *n;
  if(!t){
    return;
  }
  lprintf(0, "%s: %s (%s)\n", __func__, inet_ntoa(t->ad), t->hostname);
  if((p = (mhost *)t->prev)){
    p->next = t->next;
  }
  if((n = (mhost *)t->next)){
    n->prev = t->prev;
  }
  if(members == t){
    members = n;
  }
  free(t);
}

void member_del_message(int err, mhost *t, char *mess)
{
  int i;
  mfile *m;

  if(!t || !mess){
    return;
  }
  for(i=0;i<MAKUO_HOSTSTATE_SIZE;i++){
    if((m = t->mflist[i])){
      if(m->comm){
        if(m->comm->working){
          cprintf(0, m->comm, "error: %s: %s\n", mess, m->cmdline);
          if(err){
            lprintf(0, "[error] %s: %s: ST=%s RC=%02d: %s\n", 
              __func__, 
              mess, 
              strmstate(&(m->mdata)),
              m->retrycnt,
              m->cmdline);
          }
        }
      }
    }
  }
  for(i=0;i<MAX_COMM;i++){
    if(moption.comm[i].working){
      cprintf(0, &(moption.comm[i]), "error: %s: %s(%s)\n", mess, inet_ntoa(t->ad), t->hostname);
    }
  }
  if(err){
    lprintf(0, "[error] %s: %s: %s(%s)\n", __func__, mess, inet_ntoa(t->ad), t->hostname);
  }
}

mmark *markalloc()
{
  mmark *mm = calloc(1, sizeof(mmark));
  return(mm);
}

void markfree(mmark *mm)
{
  free(mm);
}

mmark *addmark(mmark *mm, uint32_t l, uint32_t h)
{
  mmark *nn = markalloc();
  nn->l = l;
  nn->h = h;
  if(mm){
    nn->next = mm;
    nn->prev = mm->prev;
    mm->prev = nn;
    if(nn->prev){
      nn->prev->next = nn;
    }
  }
  return(nn);
}

mmark *delmark(mmark *mm)
{
  mmark *nn = NULL;
  if(mm){
    if(mm->prev){
      mm->prev->next = mm->next;
    }
    if(mm->next){
      mm->next->prev = mm->prev;
    }
    nn = mm->next;
    markfree(mm);
  }
  return(nn);
}

void seq_addmark(mfile *m, uint32_t l, uint32_t h)
{
  if(!m || (h == l)){
    return;
  }
  m->markcount += (h - l);
  m->mark = addmark(m->mark, l, h);
}

int seq_delmark(mfile *m, uint32_t seq)
{
  uint32_t l;
  uint32_t h;
  mmark  *mm;

  if(!m){
    return(0);
  }

  for(mm=m->mark;mm;mm=mm->next){
    l = mm->l;
    h = mm->h - 1;
    if(seq == l){
      mm->l++;
      if(mm->l == mm->h){
        if(mm == m->mark){
          m->mark = mm->next;
        }
        delmark(mm);
      }
      m->markcount--;
      return(1);
    }
    if(seq == h){
      mm->h--;
      if(mm->l == mm->h){
        if(mm == m->mark){
          m->mark = mm->next;
        }
        delmark(mm);
      }
      m->markcount--;
      return(1);
    }
    if((seq>l) && (seq<h)){
      if(mm == m->mark){
        m->mark = addmark(mm, mm->l, seq);
      }else{
        addmark(mm, mm->l, seq);
      }
      mm->l = seq + 1;
      m->markcount--;
      return(1);
    }
  }
  return(0);
}

void seq_setmark(mfile *m, uint32_t l, uint32_t h)
{
  mmark *mm;
  mmark *mn;

  if(!m){
    return;
  }
  mm = m->mark;
  mn = addmark(NULL, l, h);
  while(mm){
    if((mn->h < mm->l) || (mn->l > mm->h)){
      mm = mm->next;
      continue;
    }
    if(mn->l > mm->l){
      mn->l = mm->l;
    }
    if(mn->h < mm->h){
      mn->h = mm->h;
    }
    if(mm == m->mark){
      m->mark = mm->next;
    }
    mm = delmark(mm);
  }
  if((mn->next = m->mark)){
    m->mark->prev = mn;
  }
  m->mark = mn;
  m->markcount = 0;
  for(mm=m->mark;mm;mm=mm->next){
    m->markcount += (mm->h - mm->l);
  }
}

uint32_t seq_getmark(mfile *m)
{
  uint32_t seq;
  if(!m){
    return(0);
  }
  if(!m->mark){
    return(0);
  }
  seq = m->mark->l;
  m->markcount--;
  m->mark->l++;
  if(m->mark->l == m->mark->h){
    m->mark = delmark(m->mark);
  }  
  return(seq);
}

void clr_hoststate(mfile *m)
{
  int i;
  mhost *t;
  for(t=members;t;t=t->next){
    for(i=0;i<MAKUO_HOSTSTATE_SIZE;i++){
      if(t->mflist[i] == m){
        t->mflist[i] = NULL;
        t->state[i]  = 0;
      }
    }
  }
}

void dump_hoststate(mfile *m, char *func)
{
  mhost   *t;
  uint8_t *r;
  for(t=members;t;t=t->next){
    if((r=get_hoststate(t,m))){
      lprintf(9,"%s: %s from %s %s\n", func, strrstate(*r), t->hostname, m->fn);
    }
  }
}

uint8_t *get_hoststate(mhost *t, mfile *m)
{
  int i;
  int r;
  if(!t || !m){
    return(NULL);
  }
  r = -1;
  for(i=0;i<MAKUO_HOSTSTATE_SIZE;i++){
    if(t->mflist[i] == m){
      return(&(t->state[i]));
    }else{
      if((r == -1) && !(t->mflist[i])){
        r = i;
      }
    }
  }
  if(r != -1){
    t->mflist[r] = m;
    return(&(t->state[r]));
  }
  return(NULL);
}

uint8_t *set_hoststate(mhost *t, mfile *m, uint8_t state)
{
  uint8_t *s;
  if((s = get_hoststate(t,m))){
    *s = state;
  }
  return(s);
}

int ack_clear(mfile *m, int state)
{
  uint8_t *s;
  mhost   *t;
  for(t=members;t;t=t->next){
    if(!m->sendto){
      if((s = get_hoststate(t, m))){
        if(state == -1 || *s == state){
          *s = MAKUO_RECVSTATE_NONE;
        }
      }
    }else{
      if(!memcmp(&(m->addr.sin_addr), &(t->ad), sizeof(m->addr.sin_addr))){
        if((s = get_hoststate(t, m))){
          if(state == -1 || *s == state){
            *s = MAKUO_RECVSTATE_NONE;
            return(1);
          }else{
            return(0);
          }
        }
      }
    }
  }
  if(m->sendto)
    return(-1);
  return(0);
}

/* 指定したステータスを持つ応答メッセージがあるかをチェックする
 * 引数  :
 *      m: 送信対象のファイルオブジェクト
 *  state: 検索するステータス
 *
 * 戻り値:
 *      0: 見つからなかった
 *      1: 見つかった
 *     -1: ホスト指定転送なのにホストオブジェクトが見つからない
*/
int ack_check(mfile *m, int state)
{
  uint8_t *s;
  mhost   *t;
  for(t=members;t;t=t->next){
    if(!m->sendto){
      s = get_hoststate(t,m);
      if(!s){
        lprintf(0,"[error] %s: can't get state area host=%s fn=%s\n", __func__, t->hostname, m->fn);
      }else{
        if(*s == state){
          return(1);
        }
      }
    }else{
      if(!memcmp(&(m->addr.sin_addr), &(t->ad), sizeof(m->addr.sin_addr))){
        s = get_hoststate(t,m);
        if(!s){
          lprintf(0,"[error] %s: can't get state area host=%s fn=%s\n", __func__, t->hostname, m->fn);
        }else{
          if(*s == state){
            return(1);
          }else{
            return(0);
          }
        }
      }
    }
  }
  if(m->sendto){
    return(-1);
  }
  return(0);
}

int linkcmp(mfile *m)
{
  ssize_t size;
  char ln[PATH_MAX];
  if(m){
    size = readlink(m->fn, ln, PATH_MAX);
    if(size != -1 && size < PATH_MAX){
      ln[size] = 0;
      if(!strcmp(m->ln, ln)){
        return(MAKUO_RECVSTATE_SKIP);
      }
    }
  }
  return(MAKUO_RECVSTATE_UPDATE);
}

int statcmp(struct stat *s1, struct stat *s2)
{
  if(s1->st_mtime != s2->st_mtime){
    return(MAKUO_RECVSTATE_UPDATE);
  }
  if(!geteuid() || !getegid()){
    if(s1->st_uid != s2->st_uid){
      return(MAKUO_RECVSTATE_UPDATE);
    }
    if(s1->st_gid != s2->st_gid){
      return(MAKUO_RECVSTATE_UPDATE);
    }
  }
  if((S_ISDIR(s1->st_mode)) && (S_ISDIR(s2->st_mode))){
    if(s1->st_mode != s2->st_mode)
      return(MAKUO_RECVSTATE_UPDATE);
    return(MAKUO_RECVSTATE_SKIP);
  }
  if((S_ISREG(s1->st_mode)) && (S_ISREG(s2->st_mode))){
    if(s1->st_mode != s2->st_mode)
      return(MAKUO_RECVSTATE_UPDATE);
    if(s1->st_size != s2->st_size)
      return(MAKUO_RECVSTATE_UPDATE);
    return(MAKUO_RECVSTATE_SKIP);
  }
  if(s1->st_mode == s2->st_mode){
    if(s1->st_rdev == s2->st_rdev){
      return(MAKUO_RECVSTATE_SKIP);
    }
  }
  return(MAKUO_RECVSTATE_UPDATE);
} 

int is_dir(char *path)
{
  struct stat mstat;
  if(!lstat(path,&mstat)){
    return(S_ISDIR(mstat.st_mode));
  }
  return(0);
}

int is_reg(char *path)
{
  struct stat mstat;
  if(!lstat(path,&mstat)){
    return(S_ISREG(mstat.st_mode));
  }
  return(0);
}

int set_guid(uid_t uid, gid_t gid, size_t gidn, gid_t *gids)
{
  /*----- setgids -----*/
  if(gidn && gids){
    if(setgroups(gidn, gids) == -1){
      return(-1);
    }
  }else{
    if(gid != getegid()){
      if(setgroups(1, &gid) == -1){
        return(-1);
      }
    }
  }

  /*----- setgid -----*/
  if(gid != getegid()){
    if(setegid(gid) == -1){
      return(-1);
    }
  }

  /*----- setuid -----*/
  if(uid != geteuid()){
    if(seteuid(uid) == -1){
      return(-1);
    }
  }  
  return(0);
}

void set_filestat(char *path, uid_t uid, gid_t gid, mode_t mode)
{
  struct stat fs;
  if(lstat(path, &fs) == -1){
    return;
  }
  if(fs.st_uid != uid){
    lchown(path, uid, -1);
  }
  if(fs.st_gid != gid){
    lchown(path, -1, gid);
  }
  chmod(path, mode & 07777);
}

void mtempname(char *base, char *fn, char *tn)
{
  struct stat    st;
  struct timeval tv;
  char path[PATH_MAX];
  do{
    gettimeofday(&tv, NULL);
    sprintf(tn, "%s.makuo%03u%03u", fn, getrid() % 1000,  (int)tv.tv_usec);
    sprintf(path, "%s/%s", base, tn);
  }while(lstat(tn, &st) != -1);
}

int mremove(char *base, char *name)
{
  DIR *d;
  struct dirent *dent;
  char path[PATH_MAX];
  if(!base){
    strcpy(path,name);
  }else{
    sprintf(path, "%s/%s", base, name);
  }
  if(is_dir(path)){
    if((d = opendir(path))){
      while((dent=readdir(d))){
        if(!strcmp(dent->d_name, "."))
          continue;
        if(!strcmp(dent->d_name, ".."))
          continue;
        mremove(path, dent->d_name);
      }
      closedir(d);
    }
  }
  return(remove(path));
}

int mrename(char *base, char *oldname, char *newname)
{
  char oldpath[PATH_MAX];
  char newpath[PATH_MAX];
  char tmppath[PATH_MAX];
  sprintf(oldpath,"%s/%s", base, oldname);
  sprintf(newpath,"%s/%s", base, newname);
  mtempname(base, newname, tmppath);
  rename(newpath,tmppath);
  if(rename(oldpath,newpath) == -1){
    rename(tmppath, newpath);
    return(-1);
  }
  mremove(NULL,tmppath);
  return(0);
}

int mcreatedir(char *base, char *name, mode_t mode)
{
  char *p;
  char buff[PATH_MAX];
  char path[PATH_MAX];
  strcpy(buff, name);
  strcpy(path, base);
  p = strtok(buff, "/");
  while(p){
    strcat(path, "/");
    strcat(path, p);
    if((p = strtok(NULL,"/"))){
      if(!is_dir(path)){
        remove(path);
        if(mkdir(path,mode) == -1){
          return(-1);
        }
      }
    }
  }
  return(0);
}

int mcreatenode(char *base, char *name, mode_t mode, dev_t dev)
{
  int r = -1;
  mode_t u = umask(0);
  char path[PATH_MAX];
  if(!mcreatedir(base, name, 0755)){
    sprintf(path,"%s/%s",base,name);
    r = mknod(path, mode, dev);
  }
  umask(u);
  return(r);
}

int mcreatefile(char *base, char *name, mode_t mode)
{
  int fd = -1;
  mode_t u = umask(0);
  char path[PATH_MAX];
  if(!mcreatedir(base,name,0755)){
    sprintf(path,"%s/%s",base,name);
    fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, mode & 0xFFF);
  }
  umask(u);
  return(fd);
}

int mcreatelink(char *base, char *name, char *link)
{
  char path[PATH_MAX];
  if(!mcreatedir(base,name,0755)){
    sprintf(path,"%s/%s",base,name);
    return(symlink(link,path));
  }
  return(-1);
}

int space_escape(char *str)
{
  int  r = 0;
  char buff[PATH_MAX];
  char *s = str;
  char *d = buff;
  
  while(*s){
    if(*s == ' '){
      r++;
      *(d++) = '\\';
    }
    *(d++) = *(s++);
  }
  *d = 0;
  strcpy(str, buff);
  return(r);
}

mfile *mkreq(mdata *data, struct sockaddr_in *addr, uint8_t state)
{
  mfile *a;
  if((a = mfins(MFSEND))){
    a->mdata.head.opcode = data->head.opcode;
    a->mdata.head.reqid  = data->head.reqid;
    a->mdata.head.seqno  = data->head.seqno;
    a->mdata.head.nstate = state;
    memcpy(&(a->addr), addr, sizeof(a->addr));
  }
  return(a);
}

mfile *mkack(mdata *data, struct sockaddr_in *addr, uint8_t state)
{
  mfile *a;
  for(a=mftop[MFSEND];a;a=a->next){
    if((a->mdata.head.flags & MAKUO_FLAG_ACK)      &&
       (a->mdata.head.opcode == data->head.opcode) &&
       (a->mdata.head.reqid  == data->head.reqid)  &&
       (a->mdata.head.seqno  == data->head.seqno)  &&
       (a->mdata.head.nstate == state)             &&
       (!memcmp(&(a->addr), addr, sizeof(a->addr)))){
      return(a);
    }
  }
  if((a = mfins(MFSEND))){
    a->mdata.head.flags |= MAKUO_FLAG_ACK;
    a->mdata.head.opcode = data->head.opcode;
    a->mdata.head.reqid  = data->head.reqid;
    a->mdata.head.seqno  = data->head.seqno;
    a->mdata.head.ostate = data->head.ostate;
    a->mdata.head.nstate = state;
    a->mdata.head.error  = data->head.error;
    memcpy(&(a->addr), addr, sizeof(a->addr));
  }
  return(a);
}

int atomic_read(int fd, void *buff, int size, int nb)
{
  int e;
  int r;
  int s;
  int f;

  s = size;
  f = fcntl(fd, F_GETFL, 0);
  if(nb){
    fcntl(fd, F_SETFL, f | O_NONBLOCK);
  }else{
    fcntl(fd, F_SETFL, f & ~O_NONBLOCK);
  }

  while(size){
    r = read(fd, buff, size);
    e = errno;
    /* EOF */
    if(r == 0){
      fcntl(fd, F_SETFL, f);
      return(1);
    }
    /* ERROR */
    if(r == -1){
      if(e == EINTR){
        continue;
      }
      fcntl(fd, F_SETFL, f);
      errno = e;
      return(-1);
    }
    /* SUCCESS */
    size -= r;
    buff += r;
    fcntl(fd, F_SETFL, f & ~O_NONBLOCK);
  }
  fcntl(fd, F_SETFL, f);
  return(0);
}

int data_safeget(mdata *data, void *buff, size_t size)
{
  if(data->p + size > data->data + data->head.szdata){
    return(-1);
  }
  memcpy(buff, data->p, size);
  data->p += size;
  return(0);
}

int data_safeget16(mdata *data, uint16_t *buff)
{
  int r = data_safeget(data, buff, sizeof(uint16_t));
  if(!r){
    *buff = ntohs(*buff);
  }
  return(r);
}

int data_safeget32(mdata *data, uint32_t *buff)
{
  int r = data_safeget(data, buff, sizeof(uint32_t));
  if(!r){
    *buff = ntohl(*buff);
  }
  return(r);
}

int data_safeset(mdata *data, void *buff, size_t size)
{
  if(data->head.szdata + size > MAKUO_BUFFER_SIZE){
    return(-1);
  }
  memcpy(data->data + data->head.szdata, buff, size);
  data->head.szdata += size;
  return(0);
}

int data_safeset16(mdata *data, uint16_t val)
{
  if(data->head.szdata + sizeof(uint16_t) > MAKUO_BUFFER_SIZE){
    return(-1);
  }
  val = htons(val);
  memcpy((void *)(data->data + data->head.szdata), (void *)(&val), sizeof(val));
  data->head.szdata += sizeof(uint16_t);
  return(0);
}

int data_safeset32(mdata *data, uint32_t val)
{
  if(data->head.szdata + sizeof(uint32_t) > MAKUO_BUFFER_SIZE){
    return(-1);
  }
  val = htonl(val);
  memcpy((void *)(data->data + data->head.szdata), (void *)(&val), sizeof(val));
  data->head.szdata += sizeof(uint32_t);
  return(0);
}

excludeitem *exclude_add(excludeitem *exclude, char *pattern)
{
  excludeitem *e = malloc(sizeof(excludeitem));
  e->prev = NULL;
  e->next = NULL;
  if(exclude){
    e->next = exclude;
    e->prev = exclude->prev;
    exclude->prev = e;
    if(e->prev){
      e->prev->next = e;
    }
  }
  e->pattern = malloc(strlen(pattern)+1);
  strcpy(e->pattern, pattern);
  return(e);
}

excludeitem *exclude_del(excludeitem *e)
{
  excludeitem *r = NULL;
  excludeitem *p = NULL;
  excludeitem *n = NULL;

  if(!e){
    return(NULL);
  }
  p = e->prev;
  n = e->next;
  if(p){
    p->next=n;
  }
  if(n){
    n->prev=p;
    r = n;
  }
  free(e->pattern);
  e->pattern = NULL;
  e->prev = NULL;
  e->next = NULL;
  free(e);
  return(r);
}