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 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 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 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;
}
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 main(int argc,char **argv) {
char *logappname;
// char *lockfname;
char *wrkdir;
char *cfgfile;
char *appname;
int ch;
uint8_t runmode;
int rundaemon,logundefined;
int lockmemory;
int32_t nicelevel;
uint32_t locktimeout;
int fd;
uint8_t movewarning;
struct rlimit rls;
strerr_init();
mycrc32_init();
movewarning = 0;
cfgfile=strdup(ETC_PATH "/mfs/" STR(APPNAME) ".cfg");
passert(cfgfile);
if ((fd = open(cfgfile,O_RDONLY))<0 && errno==ENOENT) {
free(cfgfile);
cfgfile=strdup(ETC_PATH "/" STR(APPNAME) ".cfg");
passert(cfgfile);
if ((fd = open(cfgfile,O_RDONLY))>=0) {
movewarning = 1;
}
}
if (fd>=0) {
close(fd);
}
locktimeout = 1800;
rundaemon = 1;
runmode = RM_RESTART;
logundefined = 0;
lockmemory = 0;
appname = argv[0];
while ((ch = getopt(argc, argv, "uvdfsc:t:h?")) != -1) {
switch(ch) {
case 'v':
printf("version: %u.%u.%u\n",VERSMAJ,VERSMID,VERSMIN);
return 0;
case 'd':
rundaemon=0;
break;
case 'f':
runmode=RM_START;
break;
case 's':
runmode=RM_STOP;
break;
case 't':
locktimeout=strtoul(optarg,NULL,10);
break;
case 'c':
free(cfgfile);
cfgfile = strdup(optarg);
passert(cfgfile);
movewarning = 0;
break;
case 'u':
logundefined=1;
break;
default:
usage(appname);
return 1;
}
}
argc -= optind;
argv += optind;
if (argc==1) {
if (strcasecmp(argv[0],"start")==0) {
runmode = RM_START;
} else if (strcasecmp(argv[0],"stop")==0) {
runmode = RM_STOP;
} else if (strcasecmp(argv[0],"restart")==0) {
runmode = RM_RESTART;
} else if (strcasecmp(argv[0],"reload")==0) {
runmode = RM_RELOAD;
} else if (strcasecmp(argv[0],"test")==0) {
runmode = RM_TEST;
} else if (strcasecmp(argv[0],"kill")==0) {
runmode = RM_KILL;
} else {
usage(appname);
return 1;
}
} else if (argc!=0) {
usage(appname);
return 1;
}
if (movewarning) {
mfs_syslog(LOG_WARNING,"default sysconf path has changed - please move " STR(APPNAME) ".cfg from "ETC_PATH"/ to "ETC_PATH"/mfs/");
}
if ((runmode==RM_START || runmode==RM_RESTART) && rundaemon) {
makedaemon();
} else {
if (runmode==RM_START || runmode==RM_RESTART) {
set_signal_handlers(0);
}
}
if (cfg_load(cfgfile,logundefined)==0) {
fprintf(stderr,"can't load config file: %s - using defaults\n",cfgfile);
}
free(cfgfile);
logappname = cfg_getstr("SYSLOG_IDENT",STR(APPNAME));
if (rundaemon) {
if (logappname[0]) {
openlog(logappname, LOG_PID | LOG_NDELAY , LOG_DAEMON);
} else {
openlog(STR(APPNAME), LOG_PID | LOG_NDELAY , LOG_DAEMON);
}
} else {
#if defined(LOG_PERROR)
if (logappname[0]) {
openlog(logappname, LOG_PID | LOG_NDELAY | LOG_PERROR, LOG_USER);
} else {
openlog(STR(APPNAME), LOG_PID | LOG_NDELAY | LOG_PERROR, LOG_USER);
}
#else
if (logappname[0]) {
openlog(logappname, LOG_PID | LOG_NDELAY, LOG_USER);
} else {
openlog(STR(APPNAME), LOG_PID | LOG_NDELAY, LOG_USER);
}
#endif
}
if (runmode==RM_START || runmode==RM_RESTART) {
rls.rlim_cur = MFSMAXFILES;
rls.rlim_max = MFSMAXFILES;
if (setrlimit(RLIMIT_NOFILE,&rls)<0) {
syslog(LOG_NOTICE,"can't change open files limit to %u",MFSMAXFILES);
}
lockmemory = cfg_getnum("LOCK_MEMORY",0);
#ifdef MFS_USE_MEMLOCK
if (lockmemory) {
rls.rlim_cur = RLIM_INFINITY;
rls.rlim_max = RLIM_INFINITY;
setrlimit(RLIMIT_MEMLOCK,&rls);
}
#endif
nicelevel = cfg_getint32("NICE_LEVEL",-19);
setpriority(PRIO_PROCESS,getpid(),nicelevel);
}
changeugid();
wrkdir = cfg_getstr("DATA_PATH",DATA_PATH);
if (runmode==RM_START || runmode==RM_RESTART) {
fprintf(stderr,"working directory: %s\n",wrkdir);
}
if (chdir(wrkdir)<0) {
mfs_arg_syslog(LOG_ERR,"can't set working directory to %s",wrkdir);
if (rundaemon) {
fputc(0,stderr);
close_msg_channel();
}
closelog();
free(logappname);
return 1;
}
free(wrkdir);
umask(cfg_getuint32("FILE_UMASK",027)&077);
/* for upgrading from previous versions of MFS */
if (check_old_locks(runmode,locktimeout)<0) {
if (rundaemon) {
fputc(0,stderr);
close_msg_channel();
}
closelog();
free(logappname);
wdunlock();
return 1;
}
if (wdlock(runmode,locktimeout)<0) {
if (rundaemon) {
fputc(0,stderr);
close_msg_channel();
}
closelog();
free(logappname);
wdunlock();
return 1;
}
remove_old_wdlock();
if (runmode==RM_STOP || runmode==RM_KILL || runmode==RM_RELOAD || runmode==RM_TEST) {
if (rundaemon) {
close_msg_channel();
}
closelog();
free(logappname);
wdunlock();
return 0;
}
#ifdef MFS_USE_MEMLOCK
if (lockmemory) {
if (getrlimit(RLIMIT_MEMLOCK,&rls)<0) {
mfs_errlog(LOG_WARNING,"error getting memory lock limits");
} else {
if (rls.rlim_cur!=RLIM_INFINITY && rls.rlim_max==RLIM_INFINITY) {
rls.rlim_cur = RLIM_INFINITY;
rls.rlim_max = RLIM_INFINITY;
if (setrlimit(RLIMIT_MEMLOCK,&rls)<0) {
mfs_errlog(LOG_WARNING,"error setting memory lock limit to unlimited");
}
}
if (getrlimit(RLIMIT_MEMLOCK,&rls)<0) {
mfs_errlog(LOG_WARNING,"error getting memory lock limits");
} else {
if (rls.rlim_cur!=RLIM_INFINITY) {
mfs_errlog(LOG_WARNING,"can't set memory lock limit to unlimited");
} else {
if (mlockall(MCL_CURRENT|MCL_FUTURE)<0) {
mfs_errlog(LOG_WARNING,"memory lock error");
} else {
mfs_syslog(LOG_NOTICE,"process memory was successfully locked in RAM");
}
} }
}
}
#else
if (lockmemory) {
mfs_syslog(LOG_WARNING,"memory lock not supported !!!");
}
#endif
fprintf(stderr,"initializing %s modules ...\n",logappname);
if (initialize()) {
if (getrlimit(RLIMIT_NOFILE,&rls)==0) {
syslog(LOG_NOTICE,"open files limit: %lu",(unsigned long)(rls.rlim_cur));
}
fprintf(stderr,"%s daemon initialized properly\n",logappname);
if (rundaemon) {
close_msg_channel();
}
if (initialize_late()) {
mainloop();
ch=0;
} else {
ch=1;
}
} else {
fprintf(stderr,"error occured during initialization - exiting\n");
if (rundaemon) {
fputc(0,stderr);
close_msg_channel();
}
ch=1;
}
destruct();
free_all_registered_entries();
signal_cleanup();
cfg_term();
strerr_term();
closelog();
free(logappname);
wdunlock();
return ch;
}
int check_old_locks(uint8_t runmode,uint32_t timeout) {
char str[13];
uint32_t l;
pid_t ptk;
char *lockfname;
lockfname = cfg_getstr("LOCK_FILE",RUN_PATH "/" STR(APPNAME) ".lock");
lfd=open(lockfname,O_RDWR);
if (lfd<0) {
if (errno==ENOENT) { // no old lock file
free(lockfname);
return 0; // ok
}
mfs_arg_errlog(LOG_ERR,"open %s error",lockfname);
free(lockfname);
return -1;
}
if (lockf(lfd,F_TLOCK,0)<0) {
if (errno!=EAGAIN) {
mfs_arg_errlog(LOG_ERR,"lock %s error",lockfname);
free(lockfname);
return -1;
}
if (runmode==RM_START) {
mfs_syslog(LOG_ERR,"old lockfile is locked - can't start");
free(lockfname);
return -1;
}
if (runmode==RM_STOP || runmode==RM_KILL || runmode==RM_RESTART) {
fprintf(stderr,"old lockfile found - trying to kill previous instance using data from old lockfile\n");
} else if (runmode==RM_RELOAD) {
fprintf(stderr,"old lockfile found - sending reload signal using data from old lockfile\n");
}
l=read(lfd,str,13);
if (l==0 || l>=13) {
mfs_arg_syslog(LOG_ERR,"wrong pid in old lockfile %s",lockfname);
free(lockfname);
return -1;
}
str[l]=0;
ptk = strtol(str,NULL,10);
if (runmode==RM_RELOAD) {
if (kill(ptk,SIGHUP)<0) {
mfs_errlog(LOG_WARNING,"can't send reload signal");
free(lockfname);
return -1;
}
fprintf(stderr,"reload signal has beed sent\n");
return 0;
}
if (runmode==RM_KILL) {
fprintf(stderr,"sending SIGKILL to previous instance (pid:%ld)\n",(long int)ptk);
if (kill(ptk,SIGKILL)<0) {
mfs_errlog(LOG_WARNING,"can't kill previous process");
free(lockfname);
return -1;
}
} else {
fprintf(stderr,"sending SIGTERM to previous instance (pid:%ld)\n",(long int)ptk);
if (kill(ptk,SIGTERM)<0) {
mfs_errlog(LOG_WARNING,"can't kill previous process");
free(lockfname);
return -1;
}
}
l=0;
fprintf(stderr,"waiting for termination ...\n");
while (lockf(lfd,F_TLOCK,0)<0) {
if (errno!=EAGAIN) {
mfs_arg_errlog(LOG_ERR,"lock %s error",lockfname);
free(lockfname);
return -1;
}
sleep(1);
l++;
if (l>=timeout) {
mfs_arg_syslog(LOG_ERR,"about %"PRIu32" seconds passed and old lockfile is still locked - giving up",l);
free(lockfname);
return -1;
}
if (l%10==0) {
mfs_arg_syslog(LOG_WARNING,"about %"PRIu32" seconds passed and old lockfile is still locked",l);
}
}
fprintf(stderr,"terminated\n");
} else {
fprintf(stderr,"found unlocked old lockfile\n");
if (runmode==RM_RELOAD) {
fprintf(stderr,"can't obtain process id using old lockfile\n");
return 0;
}
}
fprintf(stderr,"removing old lockfile\n");
close(lfd);
unlink(lockfname);
free(lockfname);
return 0;
}
int wdlock(uint8_t runmode,uint32_t timeout) {
pid_t ownerpid;
pid_t newownerpid;
uint32_t l;
lfd = open("." STR(APPNAME) ".lock",O_WRONLY|O_CREAT,0666);
if (lfd<0) {
mfs_errlog(LOG_ERR,"can't create lockfile in working directory");
return -1;
}
ownerpid = mylock(lfd);
if (ownerpid<0) {
mfs_errlog(LOG_ERR,"fcntl error");
return -1;
}
if (ownerpid>0) {
if (runmode==RM_TEST) {
fprintf(stderr,STR(APPNAME) " pid: %ld\n",(long)ownerpid);
return -1;
}
if (runmode==RM_START) {
fprintf(stderr,"can't start: lockfile is already locked by another process\n");
return -1;
}
if (runmode==RM_RELOAD) {
if (kill(ownerpid,SIGHUP)<0) {
mfs_errlog(LOG_WARNING,"can't send reload signal to lock owner");
return -1;
}
fprintf(stderr,"reload signal has beed sent\n");
return 0;
}
if (runmode==RM_KILL) {
fprintf(stderr,"sending SIGKILL to lock owner (pid:%ld)\n",(long int)ownerpid);
if (kill(ownerpid,SIGKILL)<0) {
mfs_errlog(LOG_WARNING,"can't kill lock owner");
return -1;
}
} else {
fprintf(stderr,"sending SIGTERM to lock owner (pid:%ld)\n",(long int)ownerpid);
if (kill(ownerpid,SIGTERM)<0) {
mfs_errlog(LOG_WARNING,"can't kill lock owner");
return -1;
}
}
l=0;
fprintf(stderr,"waiting for termination ... ");
fflush(stderr);
do {
newownerpid = mylock(lfd);
if (newownerpid<0) {
mfs_errlog(LOG_ERR,"fcntl error");
return -1;
}
if (newownerpid>0) {
l++;
if (l>=timeout) {
syslog(LOG_ERR,"about %"PRIu32" seconds passed and lockfile is still locked - giving up",l);
fprintf(stderr,"giving up\n");
return -1;
}
if (l%10==0) {
syslog(LOG_WARNING,"about %"PRIu32" seconds passed and lock still exists",l);
fprintf(stderr,"%"PRIu32"s ",l);
fflush(stderr);
}
if (newownerpid!=ownerpid) {
fprintf(stderr,"\nnew lock owner detected\n");
if (runmode==RM_KILL) {
fprintf(stderr,"sending SIGKILL to lock owner (pid:%ld) ... ",(long int)newownerpid);
fflush(stderr);
if (kill(newownerpid,SIGKILL)<0) {
mfs_errlog(LOG_WARNING,"can't kill lock owner");
return -1;
}
} else {
fprintf(stderr,"sending SIGTERM to lock owner (pid:%ld) ... ",(long int)newownerpid);
fflush(stderr);
if (kill(newownerpid,SIGTERM)<0) {
mfs_errlog(LOG_WARNING,"can't kill lock owner");
return -1;
}
}
ownerpid = newownerpid;
}
}
sleep(1);
} while (newownerpid!=0);
fprintf(stderr,"terminated\n");
return 0;
}
if (runmode==RM_START || runmode==RM_RESTART) {
fprintf(stderr,"lockfile created and locked\n");
} else if (runmode==RM_STOP || runmode==RM_KILL) {
fprintf(stderr,"can't find process to terminate\n");
return -1;
} else if (runmode==RM_RELOAD) {
fprintf(stderr,"can't find process to send reload signal\n");
return -1;
} else if (runmode==RM_TEST) {
fprintf(stderr,STR(APPNAME) " is not running\n");
}
return 0;
}
int sclass_load(bio *fd,uint8_t mver,int ignoreflag) {
uint8_t *databuff = NULL;
const uint8_t *ptr;
uint32_t labelmask;
uint32_t chunkcount;
uint16_t sclassid;
uint16_t arch_delay;
uint8_t create_mode;
uint8_t create_labelscnt;
uint8_t keep_labelscnt;
uint8_t arch_labelscnt;
uint8_t descrleng;
uint8_t nleng;
uint8_t admin_only;
uint8_t name[MAXSCLASSNLENG];
uint8_t i,j;
uint8_t orgroup;
uint8_t hdrleng;
if (mver<0x16) { // skip label descriptions
for (i=0 ; i<26 ; i++) {
if (bio_read(fd,&descrleng,1)!=1) {
int err = errno;
fputc('\n',stderr);
errno = err;
mfs_errlog(LOG_ERR,"loading storage class data: read error");
return -1;
}
if (descrleng>128) {
mfs_syslog(LOG_ERR,"loading storage class data: description too long");
return -1;
}
bio_skip(fd,descrleng);
}
}
if (mver==0x10) {
orgroup = 1;
} else {
if (bio_read(fd,&orgroup,1)!=1) {
int err = errno;
fputc('\n',stderr);
errno = err;
mfs_errlog(LOG_ERR,"loading storage class: read error");
return -1;
}
if (orgroup>MASKORGROUP) {
if (ignoreflag) {
mfs_syslog(LOG_ERR,"loading storage class data: too many or-groups - ignore");
} else {
mfs_syslog(LOG_ERR,"loading storage class data: too many or-groups");
return -1;
}
}
}
if (orgroup<1) {
mfs_syslog(LOG_ERR,"loading storage class data: zero or-groups !!!");
return -1;
}
databuff = malloc(3U*9U*4U*(uint32_t)orgroup);
passert(databuff);
hdrleng = (mver==0x12)?11:(mver<=0x13)?3:(mver<=0x14)?5:(mver<=0x15)?8:10;
while (1) {
if (bio_read(fd,databuff,hdrleng)!=hdrleng) {
int err = errno;
fputc('\n',stderr);
errno = err;
mfs_errlog(LOG_ERR,"loading storage class data: read error");
free(databuff);
databuff=NULL;
return -1;
}
ptr = databuff;
sclassid = get16bit(&ptr);
if (mver>0x15) {
nleng = get8bit(&ptr);
admin_only = get8bit(&ptr);
create_mode = get8bit(&ptr);
arch_delay = get16bit(&ptr);
create_labelscnt = get8bit(&ptr);
keep_labelscnt = get8bit(&ptr);
arch_labelscnt = get8bit(&ptr);
chunkcount = 0;
} else if (mver>0x14) {
nleng = 0;
admin_only = 0;
create_mode = get8bit(&ptr);
arch_delay = get16bit(&ptr);
create_labelscnt = get8bit(&ptr);
keep_labelscnt = get8bit(&ptr);
arch_labelscnt = get8bit(&ptr);
chunkcount = 0;
} else if (mver>0x13) {
nleng = 0;
admin_only = 0;
create_mode = get8bit(&ptr);
create_labelscnt = get8bit(&ptr);
keep_labelscnt = get8bit(&ptr);
arch_labelscnt = keep_labelscnt;
arch_delay = 0;
chunkcount = 0;
} else {
nleng = 0;
admin_only = 0;
create_labelscnt = get8bit(&ptr);
keep_labelscnt = create_labelscnt;
arch_labelscnt = create_labelscnt;
create_mode = CREATE_MODE_STD;
arch_delay = 0;
if (mver==0x12) {
chunkcount = get32bit(&ptr);
ptr+=4;
} else {
chunkcount = 0;
}
}
if (nleng==0) {
if (sclassid>=FIRSTSCLASSID) {
nleng = snprintf((char*)name,MAXSCLASSNLENG,"sclass_%"PRIu32,(uint32_t)(sclassid+1-FIRSTSCLASSID));
} else {
nleng = 0;
}
} else {
if (bio_read(fd,name,nleng)!=nleng) {
int err = errno;
fputc('\n',stderr);
errno = err;
mfs_errlog(LOG_ERR,"loading storage class data: read error");
free(databuff);
databuff=NULL;
return -1;
}
}
if (sclassid==0 && create_labelscnt==0 && keep_labelscnt==0 && arch_labelscnt==0 && chunkcount==0 && arch_delay==0) {
break;
}
if (create_labelscnt==0 || create_labelscnt>MAXLABELSCNT || keep_labelscnt==0 || keep_labelscnt>MAXLABELSCNT || arch_labelscnt==0 || arch_labelscnt>MAXLABELSCNT) {
mfs_arg_syslog(LOG_ERR,"loading storage class data: data format error (sclassid: %"PRIu16" ; create_mode: %"PRIu8" ; create_labelscnt: %"PRIu8" ; keep_labelscnt: %"PRIu8" ; arch_labelscnt: %"PRIu8" ; arch_delay: %"PRIu16")",sclassid,create_mode,create_labelscnt,keep_labelscnt,arch_labelscnt,arch_delay);
free(databuff);
databuff = NULL;
return -1;
}
if (sclassid==0 || sclassid>=MAXSCLASS || nleng==0) {
if (ignoreflag) {
mfs_arg_syslog(LOG_ERR,"loading storage class data: bad sclassid (%"PRIu16") - ignore",sclassid);
if (mver>0x14) {
bio_skip(fd,(create_labelscnt+keep_labelscnt+arch_labelscnt)*4*orgroup);
} else if (mver>0x13) {
bio_skip(fd,(create_labelscnt+keep_labelscnt)*4*orgroup);
} else {
bio_skip(fd,(create_labelscnt)*4*orgroup);
}
continue;
} else {
mfs_arg_syslog(LOG_ERR,"loading storage class data: bad sclassid (%"PRIu16")",sclassid);
free(databuff);
databuff=NULL;
return -1;
}
}
if (mver>0x14) {
if (bio_read(fd,databuff,(create_labelscnt+keep_labelscnt+arch_labelscnt)*4*orgroup)!=(create_labelscnt+keep_labelscnt+arch_labelscnt)*4*orgroup) {
int err = errno;
fputc('\n',stderr);
errno = err;
mfs_errlog(LOG_ERR,"loading storage class data: read error");
free(databuff);
databuff=NULL;
return -1;
}
} else if (mver>0x13) {
if (bio_read(fd,databuff,(create_labelscnt+keep_labelscnt)*4*orgroup)!=(create_labelscnt+keep_labelscnt)*4*orgroup) {
int err = errno;
fputc('\n',stderr);
errno = err;
mfs_errlog(LOG_ERR,"loading storage class data: read error");
free(databuff);
databuff=NULL;
return -1;
}
} else {
if (bio_read(fd,databuff,create_labelscnt*4*orgroup)!=create_labelscnt*4*orgroup) {
int err = errno;
fputc('\n',stderr);
errno = err;
mfs_errlog(LOG_ERR,"loading storage class data: read error");
free(databuff);
databuff=NULL;
return -1;
}
}
if (sclassid>=FIRSTSCLASSID && sclasstab[sclassid].nleng>0) {
if (ignoreflag) {
mfs_syslog(LOG_ERR,"loading storage class data: repeated sclassid - ignore");
if (chunkcount>0) {
bio_skip(fd,chunkcount*8);
}
continue;
} else {
mfs_syslog(LOG_ERR,"loading storage class data: repeated sclassid");
free(databuff);
databuff=NULL;
return -1;
}
}
ptr = databuff;
for (i=0 ; i<create_labelscnt ; i++) {
for (j=0 ; j<MASKORGROUP ; j++) {
if (j<orgroup) {
labelmask = get32bit(&ptr);
} else {
labelmask = 0;
}
sclasstab[sclassid].create_labelmasks[i][j] = labelmask;
}
}
for (i=0 ; i<keep_labelscnt ; i++) {
for (j=0 ; j<MASKORGROUP ; j++) {
if (mver>0x13) {
if (j<orgroup) {
labelmask = get32bit(&ptr);
} else {
labelmask = 0;
}
} else {
labelmask = sclasstab[sclassid].create_labelmasks[i][j];
}
sclasstab[sclassid].keep_labelmasks[i][j] = labelmask;
}
}
for (i=0 ; i<arch_labelscnt ; i++) {
for (j=0 ; j<MASKORGROUP ; j++) {
if (mver>0x14) {
if (j<orgroup) {
labelmask = get32bit(&ptr);
} else {
labelmask = 0;
}
} else {
labelmask = sclasstab[sclassid].keep_labelmasks[i][j];
}
sclasstab[sclassid].arch_labelmasks[i][j] = labelmask;
}
}
sclasstab[sclassid].create_mode = create_mode;
sclasstab[sclassid].arch_delay = arch_delay;
sclasstab[sclassid].create_labelscnt = create_labelscnt;
sclasstab[sclassid].keep_labelscnt = keep_labelscnt;
sclasstab[sclassid].arch_labelscnt = arch_labelscnt;
sclasstab[sclassid].admin_only = admin_only;
sclasstab[sclassid].nleng = nleng;
memcpy(sclasstab[sclassid].name,name,nleng);
sclasstab[sclassid].files = 0;
sclasstab[sclassid].directories = 0;
sclass_fix_has_labels_fields(sclassid);
if (sclassid>=firstneverused) {
firstneverused = sclassid+1;
}
if (chunkcount>0) {
bio_skip(fd,chunkcount*8);
}
}
free(databuff);
databuff=NULL;
return 1;
}
void charts_load(void) {
int fd;
uint32_t i,j,k,fleng,fcharts;
uint64_t *tab;
#ifdef USE_NET_ORDER
uint32_t l;
const uint8_t *ptr;
uint8_t hdr[16];
uint8_t data[8*LENG];
#else
uint32_t hdr[3];
#endif
char namehdr[101];
fd = open(statsfilename,O_RDONLY);
if (fd<0) {
if (errno!=ENOENT) {
mfs_errlog(LOG_WARNING,"error reading charts data file");
} else {
mfs_syslog(LOG_NOTICE,"no charts data file - initializing empty charts");
}
return;
}
#ifdef USE_NET_ORDER
if (read(fd,(void*)hdr,16)!=16) {
mfs_errlog(LOG_WARNING,"error reading charts data file");
close(fd);
return;
}
ptr = hdr;
i = get32bit(&ptr);
if (i!=CHARTS_FILE_VERSION) {
lseek(fd,4,SEEK_SET);
memcpy((void*)&j,hdr,4); // get first 4 bytes of hdr as a 32-bit number in "natural" order
if (j==4) {
if (charts_import_from_old_4ranges_format(fd)<0) {
mfs_syslog(LOG_WARNING,"error importing charts data from 4-ranges format");
}
} else if (j==3) {
if (charts_import_from_old_3ranges_format(fd)<0) {
mfs_syslog(LOG_WARNING,"error importing charts data from 3-ranges format");
}
} else {
mfs_syslog(LOG_WARNING,"unrecognized charts data file format - initializing empty charts");
}
close(fd);
return;
}
fleng = get32bit(&ptr);
fcharts = get32bit(&ptr);
i = get32bit(&ptr);
timepoint[SHORTRANGE]=i;
// timepoint[MEDIUMRANGE]=i/6;
// timepoint[LONGRANGE]=i/30;
// timepoint[VERYLONGRANGE]=i/(24*60);
#else
if (read(fd,(void*)hdr,sizeof(uint32_t))!=sizeof(uint32_t)) {
mfs_errlog(LOG_WARNING,"error reading charts data file");
close(fd);
return;
}
if (hdr[0]!=CHARTS_FILE_VERSION) {
if (hdr[0]==4) {
if (charts_import_from_old_4ranges_format(fd)<0) {
mfs_syslog(LOG_WARNING,"error importing charts data from 4-ranges format");
}
} else if (hdr[0]==3) {
if (charts_import_from_old_3ranges_format(fd)<0) {
mfs_syslog(LOG_WARNING,"error importing charts data from 3-ranges format");
}
} else {
mfs_syslog(LOG_WARNING,"unrecognized charts data file format - initializing empty charts");
}
close(fd);
return;
}
if (read(fd,(void*)hdr,sizeof(uint32_t)*3)!=sizeof(uint32_t)*3) {
mfs_errlog(LOG_WARNING,"error reading charts data file");
close(fd);
return;
}
fleng = hdr[0];
fcharts = hdr[1];
timepoint[SHORTRANGE]=hdr[2];
// timepoint[MEDIUMRANGE]=hdr[2]/6;
// timepoint[LONGRANGE]=hdr[2]/30;
// timepoint[VERYLONGRANGE]=hdr[2]/(24*60);
#endif
pointers[SHORTRANGE]=LENG-1;
pointers[MEDIUMRANGE]=LENG-1;
pointers[LONGRANGE]=LENG-1;
pointers[VERYLONGRANGE]=LENG-1;
for (i=0 ; i<fcharts ; i++) {
if (read(fd,namehdr,100)!=100) {
mfs_errlog(LOG_WARNING,"error reading charts data file");
close(fd);
return;
}
namehdr[100]=0;
for (j=0 ; j<statdefscount && strcmp(statdefs[j].name,namehdr)!=0 ; j++) {}
if (j>=statdefscount) {
lseek(fd,RANGES*fleng*8,SEEK_CUR);
// ignore data
} else {
for (k=0 ; k<RANGES ; k++) {
tab = series[j][k];
if (fleng>LENG) {
lseek(fd,(fleng-LENG)*sizeof(uint64_t),SEEK_CUR);
}
#ifdef USE_NET_ORDER
if (fleng<LENG) {
if (read(fd,(void*)data,8*fleng)!=(ssize_t)(8*fleng)) {
mfs_errlog(LOG_WARNING,"error reading charts data file");
close(fd);
return;
}
ptr = data;
for (l=LENG-fleng ; l<LENG ; l++) {
tab[l] = get64bit(&ptr);
}
} else {
if (read(fd,(void*)data,8*LENG)!=(ssize_t)(8*LENG)) {
mfs_errlog(LOG_WARNING,"error reading charts data file");
close(fd);
return;
}
ptr = data;
for (l=0 ; l<LENG ; l++) {
tab[l] = get64bit(&ptr);
}
}
#else
if (fleng<LENG) {
if (read(fd,(void*)(tab+(LENG-fleng)),sizeof(uint64_t)*fleng)!=(ssize_t)(sizeof(uint64_t)*fleng)) {
mfs_errlog(LOG_WARNING,"error reading charts data file");
close(fd);
return;
}
} else {
if (read(fd,(void*)tab,sizeof(uint64_t)*LENG)!=(ssize_t)(sizeof(uint64_t)*LENG)) {
mfs_errlog(LOG_WARNING,"error reading charts data file");
close(fd);
return;
}
}
#endif
}
}
}
close(fd);
mfs_syslog(LOG_NOTICE,"stats file has been loaded");
return;
}
void charts_store (void) {
int fd;
uint32_t s,i,j,p;
uint64_t *tab;
#ifdef USE_NET_ORDER
uint8_t *ptr;
uint8_t hdr[16];
uint8_t data[8*LENG];
#else
uint32_t hdr[4];
#endif
char namehdr[100];
fd = open(statsfilename,O_WRONLY | O_TRUNC | O_CREAT,0666);
if (fd<0) {
mfs_errlog(LOG_WARNING,"error creating charts data file");
return;
}
#ifdef USE_NET_ORDER
ptr = hdr;
put32bit(&ptr,CHARTS_FILE_VERSION);
put32bit(&ptr,LENG);
put32bit(&ptr,statdefscount);
put32bit(&ptr,timepoint[SHORTRANGE]);
if (write(fd,(void*)hdr,16)!=16) {
mfs_errlog(LOG_WARNING,"error writing charts data file");
close(fd);
return;
}
#else
hdr[0]=CHARTS_FILE_VERSION;
hdr[1]=LENG;
hdr[2]=statdefscount;
hdr[3]=timepoint[SHORTRANGE];
if (write(fd,(void*)hdr,sizeof(uint32_t)*4)!=sizeof(uint32_t)*4) {
mfs_errlog(LOG_WARNING,"error writing charts data file");
close(fd);
return;
}
#endif
for (i=0 ; i<statdefscount ; i++) {
s = strlen(statdefs[i].name);
memset(namehdr,0,100);
memcpy(namehdr,statdefs[i].name,(s>100)?100:s);
if (write(fd,(void*)namehdr,100)!=100) {
mfs_errlog(LOG_WARNING,"error writing charts data file");
close(fd);
return;
}
for (j=0 ; j<RANGES ; j++) {
tab = series[i][j];
p = pointers[j]+1;
#ifdef USE_NET_ORDER
ptr = data;
for (s=0 ; s<LENG ; s++) {
put64bit(&ptr,tab[(p+s)%LENG]);
}
if (write(fd,(void*)data,8*LENG)!=(ssize_t)(8*LENG)) {
mfs_errlog(LOG_WARNING,"error writing charts data file");
close(fd);
return;
}
#else
if (p<LENG) {
if (write(fd,(void*)(tab+p),sizeof(uint64_t)*(LENG-p))!=(ssize_t)(sizeof(uint64_t)*(LENG-p))) {
mfs_errlog(LOG_WARNING,"error writing charts data file");
close(fd);
return;
}
}
if (write(fd,(void*)tab,sizeof(uint64_t)*p)!=(ssize_t)(sizeof(uint64_t)*p)) {
mfs_errlog(LOG_WARNING,"error writing charts data file");
close(fd);
return;
}
#endif
}
}
close(fd);
}
