int client_socket (char * host, char * port) {
int status;
int lsock = tcpsocket();
if (lsock<0) {
logging(LOG_ERROR, "can't create socket !!!");
return -1;
}
if (tcpnonblock(lsock)<0) {
logging(LOG_ERROR, "set nonblock, error: %m");
tcpclose(lsock);
return -1;
}
status = tcpstrconnect(lsock, host, port);
if (status<0) {
logging(LOG_WARN, "connect failed, error: %m");
tcpclose(lsock);
return -1;
}
if (status==0) { // connected immediately
logging(LOG_INFO,"connected immediately");
tcpnodelay(lsock);
} else {
logging(LOG_INFO,"connecting to %s:%s...", host, port);
}
return lsock;
}
int matomlserv_init(void) {
ListenHost = cfg_getstr("MATOML_LISTEN_HOST","*");
ListenPort = cfg_getstr("MATOML_LISTEN_PORT","9419");
lsock = tcpsocket();
if (lsock<0) {
mfs_errlog(LOG_ERR,"master <-> metaloggers module: can't create socket");
return -1;
}
tcpnonblock(lsock);
tcpnodelay(lsock);
tcpreuseaddr(lsock);
if (tcpsetacceptfilter(lsock)<0 && errno!=ENOTSUP) {
mfs_errlog_silent(LOG_NOTICE,"master <-> metaloggers module: can't set accept filter");
}
if (tcpstrlisten(lsock,ListenHost,ListenPort,100)<0) {
mfs_errlog(LOG_ERR,"master <-> metaloggers module: can't listen on socket");
return -1;
}
mfs_arg_syslog(LOG_NOTICE,"master <-> metaloggers module: listen on %s:%s",ListenHost,ListenPort);
matomlservhead = NULL;
main_reloadregister(matomlserv_reload);
main_destructregister(matomlserv_term);
main_pollregister(matomlserv_desc,matomlserv_serve);
main_timeregister(TIMEMODE_SKIP_LATE,3600,0,matomlserv_status);
return 0;
}
int csserv_init(void) {
ListenHost = cfg_getstr("CSSERV_LISTEN_HOST","*");
ListenPort = cfg_getstr("CSSERV_LISTEN_PORT",DEFAULT_CS_DATA_PORT);
lsock = tcpsocket();
if (lsock<0) {
mfs_errlog(LOG_ERR,"main server module: can't create socket");
return -1;
}
tcpnonblock(lsock);
tcpnodelay(lsock);
tcpreuseaddr(lsock);
tcpresolve(ListenHost,ListenPort,&mylistenip,&mylistenport,1);
if (tcpnumlisten(lsock,mylistenip,mylistenport,100)<0) {
mfs_errlog(LOG_ERR,"main server module: can't listen on socket");
return -1;
}
if (tcpsetacceptfilter(lsock)<0 && errno!=ENOTSUP) {
mfs_errlog_silent(LOG_NOTICE,"main server module: can't set accept filter");
}
mfs_arg_syslog(LOG_NOTICE,"main server module: listen on %s:%s",ListenHost,ListenPort);
csservhead = NULL;
main_reload_register(csserv_reload);
main_destruct_register(csserv_term);
main_poll_register(csserv_desc,csserv_serve);
return 0;
}
int matomlserv_init(void) {
ListenHost = cfg_getstr("MATOML_LISTEN_HOST","*");
ListenPort = cfg_getstr("MATOML_LISTEN_PORT","9419");
lsock = tcpsocket();
if (lsock<0) {
mfs_errlog(LOG_ERR,"master <-> metaloggers module: can't create socket");
return -1;
}
tcpnonblock(lsock);
tcpnodelay(lsock);
tcpreuseaddr(lsock);
if (tcpsetacceptfilter(lsock)<0 && errno!=ENOTSUP) {
mfs_errlog_silent(LOG_NOTICE,"master <-> metaloggers module: can't set accept filter");
}
if (tcpstrlisten(lsock,ListenHost,ListenPort,100)<0) {
mfs_arg_errlog(LOG_ERR,"master <-> metaloggers module: can't listen on %s:%s",ListenHost,ListenPort);
return -1;
}
mfs_arg_syslog(LOG_NOTICE,"master <-> metaloggers module: listen on %s:%s",ListenHost,ListenPort);
matomlservhead = NULL;
ChangelogSecondsToRemember = cfg_getuint16("MATOML_LOG_PRESERVE_SECONDS",600);
if (ChangelogSecondsToRemember>3600) {
syslog(LOG_WARNING,"Number of seconds of change logs to be preserved in master is too big (%"PRIu16") - decreasing to 3600 seconds",ChangelogSecondsToRemember);
ChangelogSecondsToRemember=3600;
}
main_reloadregister(matomlserv_reload);
main_destructregister(matomlserv_term);
main_canexitregister(matomlserv_canexit);
main_pollregister(matomlserv_desc,matomlserv_serve);
main_timeregister(TIMEMODE_SKIP_LATE,3600,0,matomlserv_status);
return 0;
}
int masterproxy_init(void) {
pthread_attr_t thattr;
lsock = tcpsocket();
if (lsock<0) {
//mfs_errlog(LOG_ERR,"main master server module: can't create socket");
return -1;
}
tcpnonblock(lsock);
tcpnodelay(lsock);
// tcpreuseaddr(lsock);
if (tcpsetacceptfilter(lsock)<0 && errno!=ENOTSUP) {
// mfs_errlog_silent(LOG_NOTICE,"master proxy: can't set accept filter");
}
if (tcpstrlisten(lsock,"127.0.0.1",0,100)<0) {
// mfs_errlog(LOG_ERR,"main master server module: can't listen on socket");
tcpclose(lsock);
lsock = -1;
return -1;
}
if (tcpgetmyaddr(lsock,&proxyhost,&proxyport)<0) {
tcpclose(lsock);
lsock = -1;
return -1;
}
terminate = 0;
pthread_attr_init(&thattr);
pthread_attr_setstacksize(&thattr,0x100000);
//pthread_create(&proxythread,&thattr,masterproxy_loop,NULL);
pthread_create(&proxythread,&thattr,masterproxy_acceptor,NULL);
pthread_attr_destroy(&thattr);
return 1;
}
void matoslaserv_serve(int epoll_fd,int count,struct epoll_event *pdesc) {
//uint32_t now=main_time();
serventry *eptr,*weptr;
int ns;
weptr = (serventry *)pdesc[count].data.ptr;
if ((weptr->listen_sock == 1) && (pdesc[count].events & EPOLLIN)) {
ns=tcpaccept(lsock);
if (ns<0) {
MFSLOG(LOG_INFO,"Master<->sla socket: accept error: %m");
} else {
struct epoll_event ev;
tcpnonblock(ns);
tcpnodelay(ns);
eptr = (serventry *)malloc(sizeof(serventry));
eptr->next = matoslaservhead;
matoslaservhead = eptr;
eptr->sock = ns;
eptr->mode = HEADER;
eptr->lastread = eptr->lastwrite = get_current_time();
eptr->inputpacket.next = NULL;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->timeout = 120;
tcpgetpeer(eptr->sock,&(eptr->servip),NULL);
eptr->servstrip = matoslaserv_makestrip(eptr->servip);
eptr->version=0;
eptr->metafd=-1;
eptr->listen_sock = 0;
eptr->connection = 4;
ev.data.ptr = eptr;
ev.events = EPOLLIN | EPOLLOUT;
epoll_ctl(epoll_fd,EPOLL_CTL_ADD,ns,&ev);
}
}
if(weptr->listen_sock == 0) {
if (pdesc[count].events & (EPOLLERR|EPOLLHUP)) {
weptr->mode = KILL;
}
if ((pdesc[count].events & EPOLLIN) && weptr->mode!=KILL) {
matoslaserv_read(weptr);
weptr->lastread = get_current_time();
}
if ((pdesc[count].events & EPOLLOUT) && weptr->mode!=KILL && weptr->outputhead!=NULL) {
matoslaserv_write(weptr);
weptr->lastwrite = get_current_time();
}
}
}
int masterconn_initconnect(masterconn *eptr) {
int status;
if (eptr->masteraddrvalid==0) {
uint32_t mip,bip;
uint16_t mport;
if (tcpresolve(BindHost,NULL,&bip,NULL,1)<0) {
bip = 0;
}
eptr->bindip = bip;
if (tcpresolve(MasterHost,MasterPort,&mip,&mport,0)>=0) {
eptr->masterip = mip;
eptr->masterport = mport;
eptr->masteraddrvalid = 1;
} else {
mfs_arg_syslog(LOG_WARNING,"can't resolve master host/port (%s:%s)",MasterHost,MasterPort);
return -1;
}
}
eptr->sock=tcpsocket();
if (eptr->sock<0) {
mfs_errlog(LOG_WARNING,"create socket, error");
return -1;
}
if (tcpnonblock(eptr->sock)<0) {
mfs_errlog(LOG_WARNING,"set nonblock, error");
tcpclose(eptr->sock);
eptr->sock = -1;
return -1;
}
if (eptr->bindip>0) {
if (tcpnumbind(eptr->sock,eptr->bindip,0)<0) {
mfs_errlog(LOG_WARNING,"can't bind socket to given ip");
tcpclose(eptr->sock);
eptr->sock = -1;
return -1;
}
}
status = tcpnumconnect(eptr->sock,eptr->masterip,eptr->masterport);
if (status<0) {
mfs_errlog(LOG_WARNING,"connect failed, error");
tcpclose(eptr->sock);
eptr->sock = -1;
eptr->masteraddrvalid = 0;
return -1;
}
if (status==0) {
syslog(LOG_NOTICE,"connected to Master immediately");
masterconn_connected(eptr);
} else {
eptr->mode = CONNECTING;
eptr->conntime = monotonic_seconds();
syslog(LOG_NOTICE,"connecting ...");
}
return 0;
}
int masterconn_initconnect(serventry *eptr) {
int status;
if (eptr->masteraddrvalid==0) {
uint32_t mip,bip;
uint16_t mport;
if (tcpresolve(BindHost,NULL,&bip,NULL,1)>=0) {
eptr->bindip = bip;
} else {
eptr->bindip = 0;
}
if (tcpresolve(MasterHost,MasterPort,&mip,&mport,0)>=0) {
eptr->masterip = mip;
eptr->masterport = mport;
eptr->masteraddrvalid = 1;
} else {
MFSLOG(LOG_WARNING,"can't resolve master host/port (%s:%s)",MasterHost,MasterPort);
return -1;
}
}
eptr->sock=tcpsocket();
if (eptr->sock<0) {
MFSLOG(LOG_WARNING,"create socket, error: %m");
return -1;
}
if (tcpnonblock(eptr->sock)<0) {
MFSLOG(LOG_WARNING,"set nonblock, error: %m");
tcpclose(eptr->sock);
eptr->sock=-1;
return -1;
}
if (eptr->bindip>0) {
if (tcpnumbind(eptr->sock,eptr->bindip,0)<0) {
MFSLOG(LOG_WARNING,"can't bind socket to given ip: %m");
tcpclose(eptr->sock);
eptr->sock=-1;
return -1;
}
}
status = tcpnumconnect(eptr->sock,eptr->masterip,eptr->masterport);
if (status<0) {
MFSLOG(LOG_WARNING,"connect failed, error: %m");
tcpclose(eptr->sock);
eptr->sock=-1;
return -1;
}
if (status==0) {
MFSLOG(LOG_NOTICE,"connected to Master immediately");
masterconn_connected(eptr);
} else {
eptr->mode = CONNECTING;
MFSLOG(LOG_NOTICE,"connecting ...");
}
// syslog(LOG_NOTICE,"the masconn's sock is %d,the connection id is %d,masterconnsingleton's sock is %d,masterconnsingleton's id is %d",eptr->sock,eptr->connection,masterconnsingleton->sock,masterconnsingleton->connection);
return 0;
}
void matomlserv_reload(void) {
char *oldListenHost,*oldListenPort;
int newlsock;
oldListenHost = ListenHost;
oldListenPort = ListenPort;
ListenHost = cfg_getstr("MATOML_LISTEN_HOST","*");
ListenPort = cfg_getstr("MATOML_LISTEN_PORT","9419");
if (strcmp(oldListenHost,ListenHost)==0 && strcmp(oldListenPort,ListenPort)==0) {
free(oldListenHost);
free(oldListenPort);
mfs_arg_syslog(LOG_NOTICE,"master <-> metaloggers module: socket address hasn't changed (%s:%s)",ListenHost,ListenPort);
return;
}
newlsock = tcpsocket();
if (newlsock<0) {
mfs_errlog(LOG_WARNING,"master <-> metaloggers module: socket address has changed, but can't create new socket");
free(ListenHost);
free(ListenPort);
ListenHost = oldListenHost;
ListenPort = oldListenPort;
return;
}
tcpnonblock(newlsock);
tcpnodelay(newlsock);
tcpreuseaddr(newlsock);
if (tcpsetacceptfilter(newlsock)<0 && errno!=ENOTSUP) {
mfs_errlog_silent(LOG_NOTICE,"master <-> metaloggers module: can't set accept filter");
}
if (tcpstrlisten(newlsock,ListenHost,ListenPort,100)<0) {
mfs_arg_errlog(LOG_ERR,"master <-> metaloggers module: socket address has changed, but can't listen on socket (%s:%s)",ListenHost,ListenPort);
free(ListenHost);
free(ListenPort);
ListenHost = oldListenHost;
ListenPort = oldListenPort;
tcpclose(newlsock);
return;
}
mfs_arg_syslog(LOG_NOTICE,"master <-> metaloggers module: socket address has changed, now listen on %s:%s",ListenHost,ListenPort);
free(oldListenHost);
free(oldListenPort);
tcpclose(lsock);
lsock = newlsock;
ChangelogSecondsToRemember = cfg_getuint16("MATOML_LOG_PRESERVE_SECONDS",600);
if (ChangelogSecondsToRemember>3600) {
syslog(LOG_WARNING,"Number of seconds of change logs to be preserved in master is too big (%"PRIu16") - decreasing to 3600 seconds",ChangelogSecondsToRemember);
ChangelogSecondsToRemember=3600;
}
}
void csserv_reload(void) {
char *oldListenHost,*oldListenPort;
int newlsock;
// ThreadedServer = 1-ThreadedServer;
oldListenHost = ListenHost;
oldListenPort = ListenPort;
ListenHost = cfg_getstr("CSSERV_LISTEN_HOST","*");
ListenPort = cfg_getstr("CSSERV_LISTEN_PORT",DEFAULT_CS_DATA_PORT);
if (strcmp(oldListenHost,ListenHost)==0 && strcmp(oldListenPort,ListenPort)==0) {
free(oldListenHost);
free(oldListenPort);
mfs_arg_syslog(LOG_NOTICE,"main server module: socket address hasn't changed (%s:%s)",ListenHost,ListenPort);
return;
}
newlsock = tcpsocket();
if (newlsock<0) {
mfs_errlog(LOG_WARNING,"main server module: socket address has changed, but can't create new socket");
free(ListenHost);
free(ListenPort);
ListenHost = oldListenHost;
ListenPort = oldListenPort;
return;
}
tcpnonblock(newlsock);
tcpnodelay(newlsock);
tcpreuseaddr(newlsock);
if (tcpstrlisten(newlsock,ListenHost,ListenPort,100)<0) {
mfs_arg_errlog(LOG_ERR,"main server module: socket address has changed, but can't listen on socket (%s:%s)",ListenHost,ListenPort);
free(ListenHost);
free(ListenPort);
ListenHost = oldListenHost;
ListenPort = oldListenPort;
tcpclose(newlsock);
return;
}
if (tcpsetacceptfilter(newlsock)<0 && errno!=ENOTSUP) {
mfs_errlog_silent(LOG_NOTICE,"main server module: can't set accept filter");
}
mfs_arg_syslog(LOG_NOTICE,"main server module: socket address has changed, now listen on %s:%s",ListenHost,ListenPort);
free(oldListenHost);
free(oldListenPort);
tcpclose(lsock);
lsock = newlsock;
}
int mainserv_connect(uint32_t fwdip,uint16_t fwdport,uint32_t timeout) {
int fwdsock;
fwdsock = tcpsocket();
if (fwdsock<0) {
mfs_errlog(LOG_WARNING,"create socket, error");
return -1;
}
if (tcpnonblock(fwdsock)<0) {
mfs_errlog(LOG_WARNING,"set nonblock, error");
tcpclose(fwdsock);
return -1;
}
if (tcpnumtoconnect(fwdsock,fwdip,fwdport,timeout)<0) {
mfs_arg_errlog(LOG_WARNING,"connect to %u.%u.%u.%u:%u failed, error",(fwdip>>24)&0xFF,(fwdip>>16)&0xFF,(fwdip>>8)&0xFF,fwdip&0xFF,fwdport);
tcpclose(fwdsock);
return -1;
}
/* ning:
* 这是从 mfs matomlserv.c, matocsserv.c, matocuserv.c 三个代码里面提出来的公用代码
*/
int server_socket(char * host, char * port){
int lsock = tcpsocket();
if (lsock<0) {
logging(LOG_ERROR, "can't create socket !!!");
return -1;
}
tcpnonblock(lsock);
tcpnodelay(lsock);
tcpreuseaddr(lsock);
if (tcpsetacceptfilter(lsock)<0) {
logging(LOG_INFO,"can't set accept filter: %m"); //TODO: I do not know what this for
}
if (tcpstrlisten(lsock, host ,port,100)<0) {
logging(LOG_ERROR,"can't Listen on socket : %m");
return -1;
}
logging(LOG_INFO,"listen on %s:%s", host, port);
return lsock;
}
int matoslaserv_init() {
ListenHost = cfg_getstr("MATOSLA_LISTEN_HOST","*");
ListenPort = cfg_getstr("MATOSLA_LISTEN_PORT","9423");
BindHost = cfg_getstr("BIND_HOST","*");
MaxReconnect = cfg_getuint32("MAX_RECONNECT",10);
sla_worker_addr[0].host = cfg_getstr("SLA_SYNC_WORKER_HOST_1","*");
sla_worker_addr[0].port = cfg_getstr("SLA_SYNC_WORKER_PORT_1","9422");
sla_worker_addr[1].host = cfg_getstr("SLA_SYNC_WORKER_HOST_2","*");
sla_worker_addr[1].port = cfg_getstr("SLA_SSYNC_WORKER_PORT_2","9422");
sla_worker_addr[2].host = cfg_getstr("SLA_SSYNC_WORKER_HOST_3","*");
sla_worker_addr[2].port = cfg_getstr("SLA_SSYNC_WORKER_PORT_3","9422");
sla_worker_addr[3].host = cfg_getstr("SLA_SSYNC_WORKER_HOST_4","*");
sla_worker_addr[3].port = cfg_getstr("SLA_SSYNC_WORKER_PORT_4","9422");
first_add_listen_sock = 0;
lsock = tcpsocket();
if (lsock<0) {
MFSLOG(LOG_ERR,"matosla: socket error: %m");
fprintf(msgfd,"master <-> metaloggers module: can't create socket\n");
return -1;
}
tcpnonblock(lsock);
tcpnodelay(lsock);
tcpreuseaddr(lsock);
if (sla_worker_addr_resolve()<0) {
MFSLOG(LOG_NOTICE,"sla_worker_addr_resolve failed");
}
if (tcpsetacceptfilter(lsock)<0) {
MFSLOG(LOG_NOTICE,"matosla: can't set accept filter: %m");
}
if (tcpstrlisten(lsock,ListenHost,ListenPort,1024)<0) {
MFSLOG(LOG_ERR,"matosla: listen error: %m");
fprintf(msgfd,"master <-> metaloggers module: can't listen on socket\n");
return -1;
}
MFSLOG(LOG_NOTICE,"matosla: listen on %s:%s",ListenHost,ListenPort);
fprintf(msgfd,"master <-> metaloggers module: listen on %s:%s\n",ListenHost,ListenPort);
matoslaservhead = NULL;
main_destructregister(matoslaserv_term);
main_epollregister(matoslaserv_desc,matoslaserv_serve);
return 0;
}
//initialize listen port
int masterconn_initlisten() {
lsock = tcpsocket();
if (lsock<0) {
MFSLOG(LOG_ERR,"smtoma: socket error: %m");
fprintf(msgfd,"shadow master <-> master module: can't create socket\n");
return -1;
}
tcpnonblock(lsock);
tcpnodelay(lsock);
tcpreuseaddr(lsock);
if (tcpsetacceptfilter(lsock)<0) {
MFSLOG(LOG_NOTICE,"smtoma: can't set accept filter: %m");
}
if (tcpstrlisten(lsock,ListenHost,ListenPort,100)<0) {
MFSLOG(LOG_ERR,"smtoma: listen port:%s error: %m\n", ListenPort);
fprintf(msgfd,"shadow master to master module: can't listen on socket\n");
return -1;
}
MFSLOG(LOG_NOTICE,"smtoma: listen on %s:%s",ListenHost,ListenPort);
fprintf(msgfd,"slave <-> master module: listen on %s:%s\n",ListenHost,ListenPort);
return 0;
}
int server()
{
char buffer[1024];
int ss = server_socket("127.0.0.1", "9991");
if (ss < 0) {
logging(LOG_ERROR, "socket error!");
return -1;
}
int ns = tcptoaccept(ss, 100000);
if (ns < 0) {
logging(LOG_ERROR, "accept error!");
return -1;
}
tcpnonblock(ns);
tcpnodelay(ns);
tcptoread(ns, buffer, 10, 3000);
/*printf("read ok %d !!\n", n); */
/*printf("read data: \n%s\n", buffer); */
assert(strcmp("helloworl", buffer) == 0);
tcpclose(ns);
tcpclose(ss);
return 0;
}
void matomlserv_serve(struct pollfd *pdesc) {
uint32_t now=main_time();
matomlserventry *eptr,**kptr;
packetstruct *pptr,*paptr;
int ns;
static uint64_t lastaction = 0;
uint64_t unow;
uint32_t timeoutadd;
if (lastaction==0) {
lastaction = main_precise_utime();
}
if (lsockpdescpos>=0 && (pdesc[lsockpdescpos].revents & POLLIN)) {
ns=tcpaccept(lsock);
if (ns<0) {
mfs_errlog_silent(LOG_NOTICE,"Master<->ML socket: accept error");
} else {
tcpnonblock(ns);
tcpnodelay(ns);
eptr = malloc(sizeof(matomlserventry));
passert(eptr);
eptr->next = matomlservhead;
matomlservhead = eptr;
eptr->sock = ns;
eptr->pdescpos = -1;
eptr->mode = HEADER;
eptr->lastread = now;
eptr->lastwrite = now;
eptr->inputpacket.next = NULL;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->timeout = 10;
tcpgetpeer(eptr->sock,&(eptr->servip),NULL);
eptr->servstrip = matomlserv_makestrip(eptr->servip);
eptr->version=0;
eptr->metafd=-1;
eptr->chain1fd=-1;
eptr->chain2fd=-1;
eptr->logindex=-1;
eptr->logf=NULL;
eptr->currentversion=0;
}
}
// read
for (eptr=matomlservhead ; eptr ; eptr=eptr->next) {
if (eptr->pdescpos>=0) {
if (pdesc[eptr->pdescpos].revents & (POLLERR|POLLHUP)) {
eptr->mode = KILL;
}
if ((pdesc[eptr->pdescpos].revents & POLLIN) && eptr->mode!=KILL) {
eptr->lastread = now;
matomlserv_read(eptr);
}
}
}
// timeout fix
unow = main_precise_utime();
timeoutadd = (unow-lastaction)/1000000;
if (timeoutadd) {
for (eptr=matomlservhead ; eptr ; eptr=eptr->next) {
eptr->lastread += timeoutadd;
}
}
lastaction = unow;
// write
for (eptr=matomlservhead ; eptr ; eptr=eptr->next) {
if ((uint32_t)(eptr->lastwrite+(eptr->timeout/3))<(uint32_t)now && eptr->outputhead==NULL) {
matomlserv_createpacket(eptr,ANTOAN_NOP,0);
}
if (eptr->pdescpos>=0) {
if ((((pdesc[eptr->pdescpos].events & POLLOUT)==0 && (eptr->outputhead)) || (pdesc[eptr->pdescpos].revents & POLLOUT)) && eptr->mode!=KILL) {
eptr->lastwrite = now;
matomlserv_write(eptr);
}
if (eptr->mode!=KILL && eptr->logf && eptr->outputhead==NULL) {
matomlserv_send_old_changes(eptr, eptr->currentversion);
}
}
if ((uint32_t)(eptr->lastread+eptr->timeout)<(uint32_t)now) {
eptr->mode = KILL;
}
}
// close
kptr = &matomlservhead;
while ((eptr=*kptr)) {
if (eptr->mode == KILL) {
matomlserv_beforeclose(eptr);
tcpclose(eptr->sock);
if (eptr->inputpacket.packet) {
free(eptr->inputpacket.packet);
}
pptr = eptr->outputhead;
while (pptr) {
if (pptr->packet) {
free(pptr->packet);
}
paptr = pptr;
pptr = pptr->next;
free(paptr);
}
if (eptr->servstrip) {
free(eptr->servstrip);
}
*kptr = eptr->next;
free(eptr);
} else {
kptr = &(eptr->next);
}
}
}
void masterconn_serve(int epoll_fd,int count,struct epoll_event *pdesc) {
//uint32_t now=main_time();
serventry *weptr = NULL,*eptr = NULL;
int ns;
int ret;
struct epoll_event ev;
if(ismaster()) {
return;
}
weptr = (serventry *)pdesc[count].data.ptr;
if ((weptr->listen_sock == 1) && (pdesc[count].events & EPOLLIN) && (weptr->mode != KILL)) {
ns = tcpaccept(lsock);
if (ns<0) {
MFSLOG(LOG_INFO,"master sync thread<->shadow master socket: accept error: %m");
} else {
tcpnonblock(ns);
tcpnodelay(ns);
master_serve = (serventry *)malloc(sizeof(serventry));
eptr = master_serve;
eptr->sock = ns;
eptr->mode = HEADER;
eptr->lastread = eptr->lastwrite = get_current_time();
eptr->inputpacket.next = NULL;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->downloading = 0;
eptr->metafd=-1;
eptr->logfd=NULL;
eptr->listen_sock = 0;
eptr->connection = 3;
ev.data.ptr = eptr;
ev.events = EPOLLIN;
ret = epoll_ctl(epoll_fd,EPOLL_CTL_ADD,ns,&ev);
if (ret < 0) {
MFSLOG(LOG_NOTICE,"add epoll fail");
}
}
}
if (weptr->listen_sock == 0) {
if (weptr->mode == CONNECTING) {
if (pdesc[count].events & (EPOLLHUP | EPOLLERR)) {
masterconn_connecttest(weptr);
}
if (pdesc[count].events & EPOLLOUT) {
masterconn_connecttest(weptr);
}
} else {
if ((pdesc[count].events & (EPOLLHUP | EPOLLERR)) && (weptr->mode != KILL)) {
MFSLOG(LOG_NOTICE, "set to NULL");
weptr->mode = KILL;
}
if ((weptr->mode==HEADER || weptr->mode==DATA) && (pdesc[count].events & EPOLLIN)) { // FD_ISSET(eptr->sock,rset)) {
masterconn_read(weptr);
weptr->lastread = get_current_time();
}
if ((weptr->mode==HEADER || weptr->mode==DATA) && (pdesc[count].events & EPOLLOUT)) { // FD_ISSET(eptr->sock,wset)) {
masterconn_write(weptr);
weptr->lastwrite = get_current_time();
}
if ((weptr->mode==HEADER || weptr->mode==DATA) && weptr->lastread+Timeout<get_current_time()) {
MFSLOG(LOG_NOTICE, "set to NULL");
weptr->mode = KILL;
}
if ((weptr->mode==HEADER || weptr->mode==DATA) && weptr->lastwrite+5<get_current_time()
&& weptr->outputhead==NULL) {
masterconn_createpacket(weptr,ANTOAN_NOP,0);
}
}
}
}
/* srcs: srccnt * (chunkid:64 version:32 ip:32 port:16) */
uint8_t replicate(uint64_t chunkid,uint32_t version,uint8_t srccnt,const uint8_t *srcs) {
replication r;
uint8_t status,i,vbuffs,first;
uint16_t b,blocks;
uint32_t xcrc,crc;
uint8_t *wptr;
const uint8_t *rptr;
int s;
if (srccnt==0) {
return ERROR_EINVAL;
}
// syslog(LOG_NOTICE,"replication begin (chunkid:%08"PRIX64",version:%04"PRIX32",srccnt:%"PRIu8")",chunkid,version,srccnt);
pthread_mutex_lock(&statslock);
stats_repl++;
pthread_mutex_unlock(&statslock);
// init replication structure
r.chunkid = chunkid;
r.version = version;
r.srccnt = 0;
r.created = 0;
r.opened = 0;
r.fds = malloc(sizeof(struct pollfd)*srccnt);
passert(r.fds);
r.repsources = malloc(sizeof(repsrc)*srccnt);
passert(r.repsources);
if (srccnt>1) {
r.xorbuff = malloc(65536+4);
passert(r.xorbuff);
} else {
r.xorbuff = NULL;
}
// create chunk
status = hdd_create(chunkid,0);
if (status!=STATUS_OK) {
syslog(LOG_NOTICE,"replicator: hdd_create status: %u",status);
rep_cleanup(&r);
return status;
}
r.created = 1;
// init sources
r.srccnt = srccnt;
for (i=0 ; i<srccnt ; i++) {
r.repsources[i].chunkid = get64bit(&srcs);
r.repsources[i].version = get32bit(&srcs);
r.repsources[i].ip = get32bit(&srcs);
r.repsources[i].port = get16bit(&srcs);
r.repsources[i].sock = -1;
r.repsources[i].packet = NULL;
}
// connect
for (i=0 ; i<srccnt ; i++) {
s = tcpsocket();
if (s<0) {
mfs_errlog_silent(LOG_NOTICE,"replicator: socket error");
rep_cleanup(&r);
return ERROR_CANTCONNECT;
}
r.repsources[i].sock = s;
r.fds[i].fd = s;
if (tcpnonblock(s)<0) {
mfs_errlog_silent(LOG_NOTICE,"replicator: nonblock error");
rep_cleanup(&r);
return ERROR_CANTCONNECT;
}
s = tcpnumconnect(s,r.repsources[i].ip,r.repsources[i].port);
if (s<0) {
mfs_errlog_silent(LOG_NOTICE,"replicator: connect error");
rep_cleanup(&r);
return ERROR_CANTCONNECT;
}
if (s==0) {
r.repsources[i].mode = IDLE;
} else {
r.repsources[i].mode = CONNECTING;
}
}
if (rep_wait_for_connection(&r,CONNMSECTO)<0) {
rep_cleanup(&r);
return ERROR_CANTCONNECT;
}
// open chunk
status = hdd_open(chunkid);
if (status!=STATUS_OK) {
syslog(LOG_NOTICE,"replicator: hdd_open status: %u",status);
rep_cleanup(&r);
return status;
}
r.opened = 1;
// get block numbers
for (i=0 ; i<srccnt ; i++) {
wptr = rep_create_packet(r.repsources+i,CSTOCS_GET_CHUNK_BLOCKS,8+4);
if (wptr==NULL) {
syslog(LOG_NOTICE,"replicator: out of memory");
rep_cleanup(&r);
return ERROR_OUTOFMEMORY;
}
put64bit(&wptr,r.repsources[i].chunkid);
put32bit(&wptr,r.repsources[i].version);
}
// send packet
if (rep_send_all_packets(&r,SENDMSECTO)<0) {
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
// receive answers
for (i=0 ; i<srccnt ; i++) {
r.repsources[i].mode = HEADER;
r.repsources[i].startptr = r.repsources[i].hdrbuff;
r.repsources[i].bytesleft = 8;
}
if (rep_receive_all_packets(&r,RECVMSECTO)<0) {
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
// get block no
blocks = 0;
for (i=0 ; i<srccnt ; i++) {
uint32_t type,size;
uint64_t pchid;
uint32_t pver;
uint16_t pblocks;
uint8_t pstatus;
rptr = r.repsources[i].hdrbuff;
type = get32bit(&rptr);
size = get32bit(&rptr);
rptr = r.repsources[i].packet;
if (rptr==NULL || type!=CSTOCS_GET_CHUNK_BLOCKS_STATUS || size!=15) {
syslog(LOG_WARNING,"replicator: got wrong answer (type/size) from (%08"PRIX32":%04"PRIX16")",r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
pchid = get64bit(&rptr);
pver = get32bit(&rptr);
pblocks = get16bit(&rptr);
pstatus = get8bit(&rptr);
if (pchid!=r.repsources[i].chunkid) {
syslog(LOG_WARNING,"replicator: got wrong answer (chunk_status:chunkid:%"PRIX64"/%"PRIX64") from (%08"PRIX32":%04"PRIX16")",pchid,r.repsources[i].chunkid,r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_WRONGCHUNKID;
}
if (pver!=r.repsources[i].version) {
syslog(LOG_WARNING,"replicator: got wrong answer (chunk_status:version:%"PRIX32"/%"PRIX32") from (%08"PRIX32":%04"PRIX16")",pver,r.repsources[i].version,r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_WRONGVERSION;
}
if (pstatus!=STATUS_OK) {
syslog(LOG_NOTICE,"replicator: got status: %u from (%08"PRIX32":%04"PRIX16")",pstatus,r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return pstatus;
}
r.repsources[i].blocks = pblocks;
if (pblocks>blocks) {
blocks=pblocks;
}
}
// create read request
for (i=0 ; i<srccnt ; i++) {
if (r.repsources[i].blocks>0) {
uint32_t leng;
wptr = rep_create_packet(r.repsources+i,CUTOCS_READ,8+4+4+4);
if (wptr==NULL) {
syslog(LOG_NOTICE,"replicator: out of memory");
rep_cleanup(&r);
return ERROR_OUTOFMEMORY;
}
leng = r.repsources[i].blocks*0x10000;
put64bit(&wptr,r.repsources[i].chunkid);
put32bit(&wptr,r.repsources[i].version);
put32bit(&wptr,0);
put32bit(&wptr,leng);
} else {
rep_no_packet(r.repsources+i);
}
}
// send read request
if (rep_send_all_packets(&r,SENDMSECTO)<0) {
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
// receive data and write to hdd
for (b=0 ; b<blocks ; b++) {
// prepare receive
for (i=0 ; i<srccnt ; i++) {
if (b<r.repsources[i].blocks) {
r.repsources[i].mode = HEADER;
r.repsources[i].startptr = r.repsources[i].hdrbuff;
r.repsources[i].bytesleft = 8;
} else {
r.repsources[i].mode = IDLE;
r.repsources[i].bytesleft = 0;
}
}
// receive data
if (rep_receive_all_packets(&r,RECVMSECTO)<0) {
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
// check packets
vbuffs = 0;
for (i=0 ; i<srccnt ; i++) {
if (r.repsources[i].mode!=IDLE) {
uint32_t type,size;
uint64_t pchid;
uint16_t pblocknum;
uint16_t poffset;
uint32_t psize;
uint8_t pstatus;
rptr = r.repsources[i].hdrbuff;
type = get32bit(&rptr);
size = get32bit(&rptr);
rptr = r.repsources[i].packet;
if (rptr==NULL) {
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
if (type==CSTOCU_READ_STATUS && size==9) {
pchid = get64bit(&rptr);
pstatus = get8bit(&rptr);
rep_cleanup(&r);
if (pchid!=r.repsources[i].chunkid) {
syslog(LOG_WARNING,"replicator: got wrong answer (read_status:chunkid:%"PRIX64"/%"PRIX64") from (%08"PRIX32":%04"PRIX16")",pchid,r.repsources[i].chunkid,r.repsources[i].ip,r.repsources[i].port);
return ERROR_WRONGCHUNKID;
}
if (pstatus==STATUS_OK) { // got status too early or got incorrect packet
syslog(LOG_WARNING,"replicator: got unexpected ok status from (%08"PRIX32":%04"PRIX16")",r.repsources[i].ip,r.repsources[i].port);
return ERROR_DISCONNECTED;
}
syslog(LOG_NOTICE,"replicator: got status: %u from (%08"PRIX32":%04"PRIX16")",pstatus,r.repsources[i].ip,r.repsources[i].port);
return pstatus;
} else if (type==CSTOCU_READ_DATA && size==20+65536) {
pchid = get64bit(&rptr);
pblocknum = get16bit(&rptr);
poffset = get16bit(&rptr);
psize = get32bit(&rptr);
if (pchid!=r.repsources[i].chunkid) {
syslog(LOG_WARNING,"replicator: got wrong answer (read_data:chunkid:%"PRIX64"/%"PRIX64") from (%08"PRIX32":%04"PRIX16")",pchid,r.repsources[i].chunkid,r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_WRONGCHUNKID;
}
if (pblocknum!=b) {
syslog(LOG_WARNING,"replicator: got wrong answer (read_data:blocknum:%"PRIu16"/%"PRIu16") from (%08"PRIX32":%04"PRIX16")",pblocknum,b,r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
if (poffset!=0) {
syslog(LOG_WARNING,"replicator: got wrong answer (read_data:offset:%"PRIu16") from (%08"PRIX32":%04"PRIX16")",poffset,r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_WRONGOFFSET;
}
if (psize!=65536) {
syslog(LOG_WARNING,"replicator: got wrong answer (read_data:size:%"PRIu32") from (%08"PRIX32":%04"PRIX16")",psize,r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_WRONGSIZE;
}
} else {
syslog(LOG_WARNING,"replicator: got wrong answer (type/size) from (%08"PRIX32":%04"PRIX16")",r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
vbuffs++;
}
}
// write data
if (vbuffs==0) { // no buffers ? - it should never happen
syslog(LOG_WARNING,"replicator: no data received for block: %"PRIu16,b);
rep_cleanup(&r);
return ERROR_DISCONNECTED;
} else if (vbuffs==1) { // xor not needed, so just find block and write it
for (i=0 ; i<srccnt ; i++) {
if (r.repsources[i].mode!=IDLE) {
rptr = r.repsources[i].packet;
status = hdd_write(chunkid,0,b,rptr+20,0,65536,rptr+16);
if (status!=STATUS_OK) {
syslog(LOG_WARNING,"replicator: write status: %u",status);
rep_cleanup(&r);
return status;
}
}
}
} else {
first=1;
if (vbuffs&1) {
xcrc = 0;
} else {
xcrc = 0xD7978EEBU; // = mycrc32_zeroblock(0,0x10000);
}
for (i=0 ; i<srccnt ; i++) {
if (r.repsources[i].mode!=IDLE) {
rptr = r.repsources[i].packet;
rptr+=16; // skip chunkid,blockno,offset and size
if (first) {
memcpy(r.xorbuff+4,rptr+4,65536);
first=0;
} else {
xordata(r.xorbuff+4,rptr+4,65536);
}
crc = get32bit(&rptr);
if (crc!=mycrc32(0,rptr,65536)) {
syslog(LOG_WARNING,"replicator: received data with wrong checksum from (%08"PRIX32":%04"PRIX16")",r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_CRC;
}
xcrc^=crc;
}
}
wptr = r.xorbuff;
put32bit(&wptr,xcrc);
status = hdd_write(chunkid,0,b,r.xorbuff+4,0,65536,r.xorbuff);
if (status!=STATUS_OK) {
syslog(LOG_WARNING,"replicator: xor write status: %u",status);
rep_cleanup(&r);
return status;
}
}
}
// receive status
for (i=0 ; i<srccnt ; i++) {
if (r.repsources[i].blocks>0) {
// if (r.repsources[i].packet) {
// free(r.repsources[i].packet);
// r.repsources[i].packet=NULL;
// }
r.repsources[i].mode = HEADER;
r.repsources[i].startptr = r.repsources[i].hdrbuff;
r.repsources[i].bytesleft = 8;
} else {
r.repsources[i].mode = IDLE;
r.repsources[i].bytesleft = 0;
}
}
if (rep_receive_all_packets(&r,RECVMSECTO)<0) {
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
for (i=0 ; i<srccnt ; i++) {
if (r.repsources[i].blocks>0) {
uint32_t type,size;
uint64_t pchid;
uint8_t pstatus;
rptr = r.repsources[i].hdrbuff;
type = get32bit(&rptr);
size = get32bit(&rptr);
rptr = r.repsources[i].packet;
if (rptr==NULL || type!=CSTOCU_READ_STATUS || size!=9) {
syslog(LOG_WARNING,"replicator: got wrong answer (type/size) from (%08"PRIX32":%04"PRIX16")",r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
pchid = get64bit(&rptr);
pstatus = get8bit(&rptr);
if (pchid!=r.repsources[i].chunkid) {
syslog(LOG_WARNING,"replicator: got wrong answer (read_status:chunkid:%"PRIX64"/%"PRIX64") from (%08"PRIX32":%04"PRIX16")",pchid,r.repsources[i].chunkid,r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_WRONGCHUNKID;
}
if (pstatus!=STATUS_OK) {
syslog(LOG_NOTICE,"replicator: got status: %u from (%08"PRIX32":%04"PRIX16")",pstatus,r.repsources[i].ip,r.repsources[i].port);
rep_cleanup(&r);
return pstatus;
}
}
}
// close chunk and change version
status = hdd_close(chunkid);
if (status!=STATUS_OK) {
syslog(LOG_NOTICE,"replicator: hdd_close status: %u",status);
rep_cleanup(&r);
return status;
}
r.opened = 0;
status = hdd_version(chunkid,0,version);
if (status!=STATUS_OK) {
syslog(LOG_NOTICE,"replicator: hdd_version status: %u",status);
rep_cleanup(&r);
return status;
}
r.created = 0;
rep_cleanup(&r);
return STATUS_OK;
}
void csserv_serve(struct pollfd *pdesc) {
double now;
csserventry *eptr,**kptr;
packetstruct *pptr,*paptr;
int ns;
now = monotonic_seconds();
if (lsockpdescpos>=0 && (pdesc[lsockpdescpos].revents & POLLIN)) {
ns=tcpaccept(lsock);
if (ns<0) {
mfs_errlog_silent(LOG_NOTICE,"accept error");
} else {
tcpnonblock(ns);
tcpnodelay(ns);
eptr = malloc(sizeof(csserventry));
passert(eptr);
eptr->next = csservhead;
csservhead = eptr;
eptr->state = IDLE;
eptr->mode = HEADER;
eptr->sock = ns;
eptr->pdescpos = -1;
eptr->lastread = now;
eptr->lastwrite = now;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->jobid = 0;
eptr->idlejobs = NULL;
}
}
for (eptr=csservhead ; eptr ; eptr=eptr->next) {
if (eptr->pdescpos>=0 && (pdesc[eptr->pdescpos].revents & (POLLERR|POLLHUP))) {
eptr->state = CLOSE;
}
if (eptr->pdescpos>=0 && (pdesc[eptr->pdescpos].revents & POLLIN) && eptr->state==IDLE) {
eptr->lastread = now;
csserv_read(eptr);
}
if (eptr->state==IDLE && eptr->lastwrite+(CSSERV_TIMEOUT/3.0)<now && eptr->outputhead==NULL) {
csserv_create_packet(eptr,ANTOAN_NOP,0);
}
if (eptr->pdescpos>=0 && (pdesc[eptr->pdescpos].revents & POLLOUT) && eptr->state==IDLE) {
eptr->lastwrite = now;
csserv_write(eptr);
}
if (eptr->state==IDLE && eptr->lastread+CSSERV_TIMEOUT<now) {
// syslog(LOG_NOTICE,"csserv: connection timed out");
eptr->state = CLOSE;
}
}
kptr = &csservhead;
while ((eptr=*kptr)) {
if (eptr->state == CLOSE) {
tcpclose(eptr->sock);
csserv_close(eptr);
if (eptr->inputpacket.packet) {
free(eptr->inputpacket.packet);
}
// wptr = eptr->todolist;
// while (wptr) {
// waptr = wptr;
// wptr = wptr->next;
// free(waptr);
// }
pptr = eptr->outputhead;
while (pptr) {
if (pptr->packet) {
free(pptr->packet);
}
paptr = pptr;
pptr = pptr->next;
free(paptr);
}
*kptr = eptr->next;
free(eptr);
} else {
kptr = &(eptr->next);
}
}
}
/* srcs: srccnt * (chunkid:64 version:32 ip:32 port:16) */
uint8_t replicate(uint64_t chunkid,uint32_t version,const uint32_t xormasks[4],uint8_t srccnt,const uint8_t *srcs) {
replication r;
uint8_t status,i,j,vbuffs,first;
uint16_t b,blocks;
uint32_t xcrc[4],crc;
uint32_t codeindex,codeword;
uint8_t *wptr;
const uint8_t *rptr;
int s;
if (srccnt==0) {
return ERROR_EINVAL;
}
// syslog(LOG_NOTICE,"replication begin (chunkid:%08"PRIX64",version:%04"PRIX32",srccnt:%"PRIu8")",chunkid,version,srccnt);
pthread_mutex_lock(&statslock);
stats_repl++;
pthread_mutex_unlock(&statslock);
// init replication structure
r.chunkid = chunkid;
r.version = version;
r.srccnt = 0;
r.created = 0;
r.opened = 0;
r.fds = malloc(sizeof(struct pollfd)*srccnt);
passert(r.fds);
r.repsources = malloc(sizeof(repsrc)*srccnt);
passert(r.repsources);
if (srccnt>1) {
r.xorbuff = malloc(MFSBLOCKSIZE+4);
passert(r.xorbuff);
} else {
r.xorbuff = NULL;
}
// create chunk
status = hdd_create(chunkid,0);
if (status!=STATUS_OK) {
syslog(LOG_NOTICE,"replicator: hdd_create status: %s",mfsstrerr(status));
rep_cleanup(&r);
return status;
}
r.created = 1;
// init sources
r.srccnt = srccnt;
for (i=0 ; i<srccnt ; i++) {
r.repsources[i].chunkid = get64bit(&srcs);
r.repsources[i].version = get32bit(&srcs);
r.repsources[i].ip = get32bit(&srcs);
r.repsources[i].port = get16bit(&srcs);
r.repsources[i].sock = -1;
r.repsources[i].packet = NULL;
}
// connect
for (i=0 ; i<srccnt ; i++) {
s = tcpsocket();
if (s<0) {
mfs_errlog_silent(LOG_NOTICE,"replicator: socket error");
rep_cleanup(&r);
return ERROR_CANTCONNECT;
}
r.repsources[i].sock = s;
r.fds[i].fd = s;
if (tcpnonblock(s)<0) {
mfs_errlog_silent(LOG_NOTICE,"replicator: nonblock error");
rep_cleanup(&r);
return ERROR_CANTCONNECT;
}
s = tcpnumconnect(s,r.repsources[i].ip,r.repsources[i].port);
if (s<0) {
mfs_errlog_silent(LOG_NOTICE,"replicator: connect error");
rep_cleanup(&r);
return ERROR_CANTCONNECT;
}
if (s==0) {
r.repsources[i].mode = IDLE;
} else {
r.repsources[i].mode = CONNECTING;
}
}
if (rep_wait_for_connection(&r,CONNMSECTO)<0) {
rep_cleanup(&r);
return ERROR_CANTCONNECT;
}
// disable Nagle
for (i=0 ; i<srccnt ; i++) {
tcpnodelay(r.repsources[i].sock);
}
// open chunk
status = hdd_open(chunkid,0);
if (status!=STATUS_OK) {
syslog(LOG_NOTICE,"replicator: hdd_open status: %s",mfsstrerr(status));
rep_cleanup(&r);
return status;
}
r.opened = 1;
// get block numbers
for (i=0 ; i<srccnt ; i++) {
wptr = rep_create_packet(r.repsources+i,ANTOCS_GET_CHUNK_BLOCKS,8+4);
if (wptr==NULL) {
syslog(LOG_NOTICE,"replicator: out of memory");
rep_cleanup(&r);
return ERROR_OUTOFMEMORY;
}
put64bit(&wptr,r.repsources[i].chunkid);
put32bit(&wptr,r.repsources[i].version);
}
// send packet
if (rep_send_all_packets(&r,SENDMSECTO)<0) {
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
// receive answers
for (i=0 ; i<srccnt ; i++) {
r.repsources[i].mode = HEADER;
r.repsources[i].startptr = r.repsources[i].hdrbuff;
r.repsources[i].bytesleft = 8;
}
if (rep_receive_all_packets(&r,RECVMSECTO)<0) {
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
// get # of blocks
blocks = 0;
for (i=0 ; i<srccnt ; i++) {
uint32_t type,size;
uint64_t pchid;
uint32_t pver;
uint16_t pblocks;
uint8_t pstatus;
uint32_t ip;
rptr = r.repsources[i].hdrbuff;
type = get32bit(&rptr);
size = get32bit(&rptr);
rptr = r.repsources[i].packet;
ip = r.repsources[i].ip;
if (rptr==NULL || type!=CSTOAN_CHUNK_BLOCKS || size!=15) {
syslog(LOG_WARNING,"replicator,get # of blocks: got wrong answer (type:0x%08"PRIX32"/size:0x%08"PRIX32") from (%u.%u.%u.%u:%04"PRIX16")",type,size,(ip>>24)&0xFF,(ip>>16)&0xFF,(ip>>8)&0xFF,ip&0xFF,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_DISCONNECTED;
}
pchid = get64bit(&rptr);
pver = get32bit(&rptr);
pblocks = get16bit(&rptr);
pstatus = get8bit(&rptr);
if (pchid!=r.repsources[i].chunkid) {
syslog(LOG_WARNING,"replicator,get # of blocks: got wrong answer (chunk_status:chunkid:%"PRIX64"/%"PRIX64") from (%u.%u.%u.%u:%04"PRIX16")",pchid,r.repsources[i].chunkid,(ip>>24)&0xFF,(ip>>16)&0xFF,(ip>>8)&0xFF,ip&0xFF,r.repsources[i].port);
rep_cleanup(&r);
return ERROR_WRONGCHUNKID;
}
//init the thread's socket
static int sla_sync_socket_init(serventry *eptr,pthread_t tid) {
int status;
uint32_t shadow_ip = 0,bind_ip = 0,bip = 0;
uint16_t shadow_port;
int num;
int count = 0;
num = sla_worker_thread_indent(tid);
if (tcpresolve(sla_worker_addr[num].host,sla_worker_addr[num].port,&shadow_ip,&shadow_port,0)>=0) {
eptr->masterip = shadow_ip;
eptr->masterport = shadow_port;
} else {
MFSLOG(LOG_ERR,"resolve shadow's addr failed");
return -1;
}
eptr->sock = tcpsocket();
if (eptr->sock < 0) {
MFSLOG(LOG_ERR,"socket init failed");
return -1;
}
if (tcpnonblock(eptr->sock)<0) {
MFSLOG(LOG_WARNING,"set nonblock, error: %m");
tcpclose(eptr->sock);
eptr->sock=-1;
return -1;
}
tcpgetpeer(eptr->sock,&(eptr->servip),NULL);
eptr->servstrip = matoslaserv_makestrip(eptr->servip);
if (tcpresolve(BindHost,NULL,&bind_ip,NULL,1)>=0) {
eptr->bindip = bip;
} else {
eptr->bindip = 0;
}
if (eptr->bindip>0) {
if (tcpnumbind(eptr->sock,eptr->bindip,0)<0) {
MFSLOG(LOG_WARNING,"can't bind socket to given ip: %m");
tcpclose(eptr->sock);
eptr->sock=-1;
return -1;
}
}
eptr->cur_file = (file_info *)malloc(sizeof(file_info));
if (eptr->cur_file == NULL) {
MFSLOG(LOG_ERR,"FATAL,malloc file_info failed");
} else {
eptr->cur_file->fd = NULL;
eptr->cur_file->idx = 0;
}
while(count < MaxConnect) {
status = tcpnumconnect(eptr->sock,eptr->masterip,eptr->masterport);
if (status<0) {
MFSLOG(LOG_WARNING,"connect failed, error: %m (1)");
tcpclose(eptr->sock);
eptr->sock=-1;
return -1;
}
if (status==0) {
MFSLOG(LOG_NOTICE,"connected to slave");
tcpnodelay(eptr->sock);
eptr->mode=HEADER;
eptr->inputpacket.next = NULL;
eptr->inputpacket.bytesleft = 8;
eptr->inputpacket.startptr = eptr->hdrbuff;
eptr->inputpacket.packet = NULL;
eptr->outputhead = NULL;
eptr->outputtail = &(eptr->outputhead);
eptr->lastread = eptr->lastwrite = get_current_time();
count = 100;
break;
} else {
MFSLOG(LOG_ERR,"connect failed, error: %m (2)");
}
count++;
sleep(1);
}
return 0;
}