/*
* 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);
}