ex_t dbx_recover(bfpath *bfp, bool catastrophic, bool force)
{
dbe_t *env = xcalloc(1, sizeof(dbe_t));
/* set exclusive/write lock for recovery */
while ((force || needs_recovery())
&& (db_try_glock(bfp, F_WRLCK, F_SETLKW) <= 0))
rand_sleep(10000,1000000);
/* ok, when we have the lock, a concurrent process may have
* proceeded with recovery */
if (!(force || needs_recovery()))
return EX_OK;
if (DEBUG_DATABASE(0))
fprintf(dbgout, "running %s data base recovery\n",
catastrophic ? "catastrophic" : "regular");
env = dbe_xinit(env, bfp,
catastrophic ? DB_RECOVER_FATAL : DB_RECOVER);
if (env == NULL) {
exit(EX_ERROR);
}
clear_lockfile();
dbx_cleanup_lite(env);
return EX_OK;
}
void
remainderSection(int id)
{
// DO NOT TOUCH THIS FUNCTION
int isFemale = femaleOnly ? 1 : (id % 2 == 0);
rand_sleep();
}
int dot_lockfile(const char *path, VSTRING *why)
{
char *lock_file;
int count;
struct stat st;
int fd;
int status = -1;
lock_file = concatenate(path, ".lock", (char *) 0);
for (count = 1; /* void */ ; count++) {
/*
* Attempt to create the lock. This code relies on O_EXCL | O_CREAT
* to not follow symlinks. With NFS file systems this operation can
* at the same time succeed and fail with errno of EEXIST.
*/
if ((fd = open(lock_file, O_WRONLY | O_EXCL | O_CREAT, 0)) >= 0) {
close(fd);
status = 0;
break;
}
if (count >= var_flock_tries)
break;
/*
* We can deal only with "file exists" errors. Any other error means
* we better give up trying.
*/
if (errno != EEXIST)
break;
/*
* Break the lock when it is too old. Give up when we are unable to
* remove a stale lock.
*/
if (stat(lock_file, &st) == 0)
if (time((time_t *) 0) > st.st_ctime + var_flock_stale)
if (unlink(lock_file) < 0)
if (errno != ENOENT)
break;
rand_sleep(var_flock_delay * MILLION, var_flock_delay * MILLION / 2);
}
if (status && why)
vstring_sprintf(why, "unable to create lock file %s: %m", lock_file);
myfree(lock_file);
return (status);
}
static int dbx_sync(DB_ENV *dbe, int ret)
{
#if DB_AT_LEAST(3,0) && DB_AT_MOST(4,0)
/* flush dirty pages in buffer pool */
while (ret == DB_INCOMPLETE) {
rand_sleep(10000,1000000);
ret = BF_MEMP_SYNC(dbe, NULL);
}
#else
(void)dbe;
ret = 0;
#endif
return ret;
}
int main(int argc, char **argv)
{
int delay;
int variation;
msg_vstream_init(argv[0], VSTREAM_ERR);
if (argc != 3)
msg_fatal("usage: %s delay variation", argv[0]);
if ((delay = atoi(argv[1])) <= 0)
msg_fatal("bad delay: %s", argv[1]);
if ((variation = atoi(argv[2])) < 0)
msg_fatal("bad variation: %s", argv[2]);
rand_sleep(delay * 1000000, variation * 1000000);
exit(0);
}
static ex_t get_robx(bfpath *bfp)
{
double rx;
int ret = 0;
init_wordlist("word", bfp->filepath, 0, WL_REGULAR);
rx = compute_robinson_x();
if (rx < 0)
return EX_ERROR;
if (onlyprint)
printf("%f\n", rx);
else {
dsv_t val;
word_t *word_robx = word_news(ROBX_W);
/* since compute_robinson_x() closes the wordlists,
init_wordlist() must be called again */
init_wordlist("word", bfp->filepath, 0, WL_REGULAR);
open_wordlists(DS_WRITE);
val.goodcount = 0;
val.spamcount = (uint32_t) (rx * 1000000);
do {
ret = ds_write(word_lists->dsh, word_robx, &val);
if (ret == DS_ABORT_RETRY) {
rand_sleep(1000, 1000000);
begin_wordlist(word_lists);
}
} while (ret == DS_ABORT_RETRY);
close_wordlists(true);
free_wordlists();
word_free(word_robx);
}
return ret ? EX_ERROR : EX_OK;
}
static int do_discover_conn(struct conn * conn,struct discovery_info * di)
{
rand_sleep(conf_max_discovery_interval);
struct wtpinfo * wtpinfo;
wtpinfo = get_wtpinfo();
// wtpinfo_print(wtpinfo);
// struct timespec tstart,tcur;
struct radioinfo ri;
memset(&ri,0,sizeof(ri));
ri.rmac[0]=6;
ri.rmac[2]=14;
ri.rmac[3]=14;
ri.rmac[4]=14;
ri.rmac[5]=14;
ri.rmac[6]=14;
ri.rmac[7]=14;
#ifdef WITH_CW_LOG_DEBUG
char str[100];
sock_addrtostr((struct sockaddr*)&conn->addr,str,100);
cw_log_debug0("Sending discovery request to %s",str);
#endif
int rc;
do {
rc = cwsend_discovery_request(conn,&ri,wtpinfo);
if (rc<0){
if (errno == EINTR)
continue;
if (errno == EMSGSIZE){
conn->mtu-=4;
cw_log_debug2("Setting mtu to %i",conn->mtu);
continue;
}
}
break;
}while (rc<0);
if (rc < 0 )
{
char str[100];
sock_addrtostr((struct sockaddr*)&conn->addr,str,100);
cw_log(LOG_ERR,"Error sending discovery request to %s: %s",str,strerror(errno));
return 0;
}
struct connlist * connlist;
connlist = connlist_create(30);
// clock_gettime(CLOCK_REALTIME,&tstart);
//
int tstart = time(0);
int treset = 0;
do {
char buf[2048];
int buflen=2048;
struct sockaddr_storage sa;
socklen_t fromlen=sizeof(struct sockaddr_storage);
rc = recvfrom(conn->sock,buf,buflen,0,(struct sockaddr*)&sa,&fromlen);
if (rc<0){
if (errno==EINTR)
rc=0;
if (errno==EAGAIN)
rc=0;
if (errno==EWOULDBLOCK)
rc=0;
}
if (rc>0) {
#ifdef WITH_CW_LOG_DEBUG
char str[100];
sock_addrtostr((struct sockaddr*)&sa,str,100);
cw_log_debug0("Received packet from %s",str);
#endif
struct conn * rconn;
rconn = connlist_get(connlist,(struct sockaddr*)&sa);
if (!rconn){
rconn = conn_create_noq(conn->sock,(struct sockaddr*)&sa); //msg_cb,NULL,0);
// rconn->pmsgarg=conn->pmsgarg;
rconn->mtu = conn->mtu;
rconn->seqnum=conn->seqnum;
connlist_add(connlist,rconn);
}
conn_process_packet(rconn,(uint8_t*)buf,rc,msg_cb,di);
}
/* reset discovery timer after we have received the first response */
if ( di->response_count == 1 && !treset ){
tstart=time(0);
treset=1;
}
//clock_gettime(CLOCK_REALTIME,&tcur);
// printf("TTSub: %i %i\n",time(0)-tstart, conf_discovery_interval);
}while(time(0)-tstart < conf_discovery_interval && rc>=0 );
if (rc <0){
char str[100];
sock_addrtostr((struct sockaddr*)&conn->addr,str,100);
cw_log(LOG_ERR,"Error sendings discovery request to %s: %s",str,strerror(errno));
}
connlist_destroy(connlist);
return 1;
}
