boolean
fsysdep_sync (openfile_t e, const char *zmsg)
{
#if FSYNC_ON_CLOSE
int o;
#endif
#if USE_STDIO
if (fflush (e) == EOF)
{
ulog (LOG_ERROR, "%s: fflush: %s", zmsg, strerror (errno));
return FALSE;
}
#endif
#if FSYNC_ON_CLOSE
#if USE_STDIO
o = fileno (e);
#else
o = e;
#endif
if (fsync (o) < 0)
{
ulog (LOG_ERROR, "%s: fsync: %s", zmsg, strerror (errno));
return FALSE;
}
#endif
return TRUE;
}
static void dump_status(struct uplink *uplink) {
const char *status = "unknown";
if (uplink->fd == -1) {
status = "offline";
} else {
switch (uplink->auth_status) {
case AUTHENTICATED:
status = "online";
break;
case SENT:
case NOT_STARTED:
status = "connecting";
break;
case FAILED:
status = "bad-auth";
break;
}
}
ulog(LLOG_DEBUG, "Dump status %s\n", status);
if (!uplink->status_file)
return;
FILE *sf = fopen(uplink->status_file, "w");
if (!sf) {
ulog(LLOG_ERROR, "Couldn't dump current uplink status to file %s: %s\n", uplink->status_file, strerror(errno));
return;
}
fprintf(sf, "%s\t%llu\n", status, (unsigned long long)time(NULL));
if (fclose(sf) == EOF)
ulog(LLOG_WARN, "Error closing status file %s/%p: %s\n", uplink->status_file, (void *)sf, strerror(errno));
}
static int netlink_send(int s, struct cn_msg *msg)
{
struct nlmsghdr *nlh;
unsigned int size;
int err;
char buf[128];
struct cn_msg *m;
size = NLMSG_SPACE(sizeof(struct cn_msg) + msg->len);
nlh = (struct nlmsghdr *)buf;
nlh->nlmsg_seq = seq++;
nlh->nlmsg_pid = getpid();
nlh->nlmsg_type = NLMSG_DONE;
nlh->nlmsg_len = NLMSG_LENGTH(size - sizeof(*nlh));
nlh->nlmsg_flags = 0;
m = NLMSG_DATA(nlh);
#if 0
ulog("%s: [%08x.%08x] len=%u, seq=%u, ack=%u.\n",
__func__, msg->id.idx, msg->id.val, msg->len, msg->seq, msg->ack);
#endif
memcpy(m, msg, sizeof(*m) + msg->len);
err = send(s, nlh, size, 0);
if (err == -1)
ulog("Failed to send: %s [%d].\n",
strerror(errno), errno);
return err;
}
void* UThread::startThread(void* ptr)
{
UThread* thread = (UThread *) ptr;
ulog(ULOG_INFO,"starting thread %s",thread->mThreadName?thread->mThreadName:"");
//进行子类的向下虚拟调用
thread->handleRun();
ulog(ULOG_INFO,"thread ended %s",thread->mThreadName?thread->mThreadName:"");
return (void *)1;
}
boolean
fcopy_open_file (FILE *efrom, const char *zto, boolean fpublic, boolean fmkdirs, boolean fsignals)
{
FILE *eto;
char ab[8192];
size_t c;
eto = esysdep_fopen (zto, fpublic, FALSE, fmkdirs);
if (eto == NULL)
return FALSE;
while ((c = fread (ab, sizeof (char), sizeof ab, efrom)) != 0)
{
if (fwrite (ab, sizeof (char), (size_t) c, eto) != c)
{
ulog (LOG_ERROR, "fwrite: %s", strerror (errno));
(void) fclose (eto);
(void) remove (zto);
return FALSE;
}
if (fsignals && FGOT_SIGNAL ())
{
/* Log the signal. */
ulog (LOG_ERROR, (const char *) NULL);
(void) fclose (eto);
(void) remove (zto);
return FALSE;
}
}
if (! fsysdep_sync (eto, zto))
{
(void) fclose (eto);
(void) remove (zto);
return FALSE;
}
if (fclose (eto) != 0)
{
ulog (LOG_ERROR, "fclose: %s", strerror (errno));
(void) remove (zto);
return FALSE;
}
if (ferror (efrom))
{
ulog (LOG_ERROR, "fread: %s", strerror (errno));
(void) remove (zto);
return FALSE;
}
return TRUE;
}
void readQueryFromClient(aeEventLoop *el, int fd, httpClient *c) {
char buf[CCACHE_IOBUF_LEN];
int nread;
nread = read(fd, buf, CCACHE_IOBUF_LEN);
if (nread == -1) {
if (errno == EAGAIN) { /* try again */
nread = 0;
} else {
ulog(CCACHE_VERBOSE, "Reading from client: %s",strerror(errno));
freeClient(c);
return;
}
} else if (nread == 0) {
ulog(CCACHE_VERBOSE, "End of client request");
freeClient(c);
return;
}
if (nread>0) {
printf("Read Request: %.2lf \n", (double)(clock()));
c->lastinteraction = time(NULL);
listMoveNodeToTail(el->clients,c->elNode);
/* NOTICE: nread or nread-1 */
switch(requestParse(c->req,buf,buf+nread)){
case parse_not_completed:
break;
case parse_completed:
{
int handle_result = requestHandle(c->req,c->rep,el->cache,c);
if(handle_result == HANDLER_BLOCK){
blockClient(el,c);
}
else {
if (_installWriteEvent(el, c) != CCACHE_OK) return;
printf("Install Write: %.2lf\n", (double)(clock()));
/* For HANDLE_OK there is nothing to do */
if(handle_result == HANDLER_ERR) requestHandleError(c->req,c->rep);
}
break;
}
case parse_error:
if (_installWriteEvent(el, c) != CCACHE_OK) {
return;
}
requestHandleError(c->req,c->rep);
break;
default:
break;
};
}
}
void nodelib_version(void)
{
ulog(ULOG_INFO, "NODElib version information\n");
ulog(ULOG_INFO, "---------------------------\n");
ulog(ULOG_INFO, " USER : %s\n", NODELIB_USER);
ulog(ULOG_INFO, " HOST : %s\n", NODELIB_HOST);
ulog(ULOG_INFO, " DATE : %s\n", NODELIB_DATE);
ulog(ULOG_INFO, " UNAME : %s\n", NODELIB_UNAME);
ulog(ULOG_INFO, " VERSION : %s\n", NODELIB_VERSION);
ulog(ULOG_INFO, " COMPILER : %s\n", NODELIB_COMPILER);
ulog(ULOG_INFO, "COPYRIGHT : %s\n", NODELIB_COPYRIGHT);
}
void sendReplyToClient(aeEventLoop *el, int fd, httpClient *c) {
int nwritten = 0;
CCACHE_NOTUSED(el);
if(c->rep) {
sds obuf = replyToBuffer(c->rep);
int towrite = sdslen(obuf) - c->bufpos;
nwritten = write(fd, obuf+c->bufpos,towrite);
/* Content */
if (nwritten == -1) {
if (errno == EAGAIN) {
nwritten = 0;
} else {
ulog(CCACHE_VERBOSE,
"Error writing to client: %s", strerror(errno));
freeClient(c);
return;
}
}
c->lastinteraction = time(NULL);
listMoveNodeToTail(el->clients,c->elNode);
if(nwritten<towrite) {
c->bufpos += nwritten;
}
else {
#ifdef AE_MAX_CLIENT_IDLE_TIME
resetClient(c);
#else
freeClient(c);
#endif
aeModifyFileEvent(el,c->fd,AE_READABLE,c);
printf("Send Reply: %.2lf\n", (double)(clock()));
}
}
}
static jint tagThreads(ThreadModule * threadModule, jvmtiEnv * jvmti, jlong beginTag) {
jthread * threads;
jvmtiError err;
int i;
err = (*jvmti)->GetAllThreads(jvmti, &threadModule->threadCount, &threads);
CHECK_ERROR_AND_RETURN(jvmti, err, "get all thread error", JNI_ERR);
threadModule->threadInfos = calloc(threadModule->threadCount, sizeof(ThreadInfo));
for (i = 0; i < threadModule->threadCount; i++) {
jvmtiThreadInfo aInfo;
int tag = beginTag + i;
err = (*jvmti)->GetThreadInfo(jvmti, threads[i], &aInfo);
print_if_error(jvmti, err, "get thread info error");
if (err == JVMTI_ERROR_NONE) {
(*jvmti)->SetTag(jvmti, threads[i], tag);
threadModule->threadInfos[i].name = strdup(aInfo.name);
#ifdef DEBUG
ulog("tag thread: %s to %d\n", threadModule->threadInfos[i].name, tag);
#endif
deallocate(jvmti, aInfo.name);
}
}
deallocate(jvmti, threads);
return JNI_OK;
}
static int netlink_send(int s, struct cn_msg *msg)
{
struct nlmsghdr *nlh;
unsigned int size;
int err;
char buf[CONNECTOR_MAX_MSG_SIZE];
struct cn_msg *m;
size = NLMSG_SPACE(sizeof(struct cn_msg) + msg->len);
nlh = (struct nlmsghdr *)buf;
nlh->nlmsg_seq = seq++;
nlh->nlmsg_pid = getpid();
nlh->nlmsg_type = NLMSG_DONE;
nlh->nlmsg_len = NLMSG_LENGTH(size - sizeof(*nlh));
nlh->nlmsg_flags = 0;
m = NLMSG_DATA(nlh);
memcpy(m, msg, sizeof(*m) + msg->len);
err = send(s, nlh, size, 0);
if (err == -1)
ulog(LOG_ERR, "Failed to send: %s [%d].\n", strerror(errno), errno);
return err;
}
void sensor_server() {
struct SensorService service;
sensorservice_initialize(&service);
RegisterAs("SensorServer");
// Create the thing sending us sensor messages.
Create(HIGH, sensor_notifier);
tid_t stream = CreateStream("SensorServerStream");
int tid;
SensorServerMessage msg, rply;
for(;;) {
Receive(&tid, (char *) &msg, sizeof(msg));
switch(msg.type) {
case SENSOR_EVENT_REQUEST:
rply.type = SENSOR_EVENT_RESPONSE;
Reply(tid, (char *) &rply, sizeof(rply));
sensorservice_process_data(&service, msg.data);
publish(&service, stream);
break;
default:
ulog("Invalid SensorServer Request");
}
}
Exit();
}
void xalloc_report(void)
{
XALLOC_REC *rec;
HASH_NODE *node = NULL;
int index = 0, i;
char line[LEN], *l;
struct info
{ int pos; char *fmt; int offset;
} pinfo[] = { { 8, "%d", offsetof(XALLOC_REC, id) },
{ 24, "%s", offsetof(XALLOC_REC, file) },
{ 32, "%d", offsetof(XALLOC_REC, line) },
{ 48, "%s", offsetof(XALLOC_REC, name) },
{ 64, "0x%x", offsetof(XALLOC_REC, ptr) },
{ 0, "%d", offsetof(XALLOC_REC, size) }};
ulog(ULOG_INFO, "xalloc-report: ");
if(!xalloc_initialized) {
ulog(ULOG_INFO, "nothing to report.\n");
return;
}
ulog(ULOG_INFO, "\n-------------\n");
ulog(ULOG_INFO, "\ttotal xmalloc() & xcalloc() : %d\n",
xalloc_numalloc);
ulog(ULOG_INFO, "\ttotal xrealloc() & xrecalloc() : %d\n",
xalloc_numrealloc);
ulog(ULOG_INFO, "\ttotal xfree() & xcfree() : %d\n\n",
xalloc_numfree);
if(hash_iterate(xalloc_hash, &index, &node)) {
node = NULL, index = 0;
ulog(ULOG_INFO, "ID\tFILE\t\tLINE\tSOURCE\t\tADDRESS\t\tSIZE\n");
ulog(ULOG_INFO, "--\t----\t\t----\t------\t\t-------\t\t----\n");
while((rec = hash_iterate(xalloc_hash, &index, &node)) != NULL) {
l = line;
for(i = 0; i < sizeof(pinfo) / sizeof(struct info); i++) {
sprintf(l, pinfo[i].fmt, *(int *)((char *)rec + pinfo[i].offset));
l = l + strlen(l);
while(l < line + pinfo[i].pos) *l++ = ' ';
}
ulog(ULOG_INFO, "%s\n", line);
}
}
ulog(ULOG_INFO, "\n\n");
}
char *
zsysdep_local_file (const char *zfile, const char *zpubdir, boolean *pfbadname)
{
const char *zdir;
if (pfbadname != NULL)
*pfbadname = FALSE;
if (*zfile == '/')
return zbufcpy (zfile);
if (*zfile != '~')
zdir = zpubdir;
else
{
if (zfile[1] == '\0')
return zbufcpy (zpubdir);
if (zfile[1] == '/')
{
zdir = zpubdir;
zfile += 2;
}
else
{
size_t cuserlen;
char *zcopy;
struct passwd *q;
++zfile;
cuserlen = strcspn ((char *) zfile, "/");
zcopy = zbufalc (cuserlen + 1);
memcpy (zcopy, zfile, cuserlen);
zcopy[cuserlen] = '\0';
q = getpwnam (zcopy);
if (q == NULL)
{
ulog (LOG_ERROR, "User %s not found", zcopy);
ubuffree (zcopy);
if (pfbadname != NULL)
*pfbadname = TRUE;
return NULL;
}
ubuffree (zcopy);
if (zfile[cuserlen] == '\0')
return zbufcpy (q->pw_dir);
zdir = q->pw_dir;
zfile += cuserlen + 1;
}
}
return zsysdep_in_dir (zdir, zfile);
}
JNIEXPORT jint JNICALL Agent_OnAttach(JavaVM *vm, char *options, void *reserved) {
jint rc;
jvmtiEnv *jvmti;
JNIEnv *jniEnv;
jvmtiError err;
char * optionType;
char * otherOption = NULL;
/* Get JVMTI environment */
jvmti = NULL;
rc = (*vm)->GetEnv(vm, (void **) &jvmti, JVMTI_VERSION);
if (rc != JNI_OK) {
ulog("ERROR: Unable to create jvmtiEnv, error=%d\n", rc);
return JNI_ERR;
}
if (jvmti == NULL) {
ulog("ERROR: No jvmtiEnv* returned from GetEnv\n");
return JNI_ERR;
}
/////////////jni/////////////
rc = (*vm)->GetEnv(vm, (void **) &jniEnv, JNI_VERSION_1_2);
if (rc != JNI_OK) {
ulog("ERROR: Unable to create jnienv, error=%d\n", rc);
return JNI_ERR;
}
if (jvmti == NULL) {
ulog("ERROR: No jnienv* returned from GetEnv\n");
return JNI_ERR;
}
////////////////////////////
#ifdef DEBUG
ulog("options: %s\n", options);
#endif
parseOption(options, &optionType, &otherOption);
#ifdef DEBUG
ulog("optionType:%s, otherOption: %s\n", optionType, otherOption==NULL?"":otherOption);
#endif
if (strcmp(optionType, DUMP_REFER) == 0) {
rc = printReferAction(jvmti, jniEnv, otherOption);
} else if (strcmp(optionType, DUMP_ROOT) == 0) {
rc = printRootReferAction(jvmti, otherOption);
} else {
rc = JNI_ERR;
ulog("ERROR: invalid options\n");
}
err = (*jvmti)->DisposeEnvironment(jvmti);
CHECK_ERROR_AND_RETURN(jvmti, err, "DisposeEnvironment error", JNI_ERR);
return rc;
}
static void train_reserved_node_reserved(int index, DisplayData *data, track_node *node) {
// ulog("Train widget got reserved event for index %d, train %d, node %s", index, data->id, node->name);
unsigned int j;
for (j = 0; j < MAX_RESERVED_NODES; ++j) {
if (data->reserved_nodes[j] == 0) {
data->reserved_nodes[j] = node;
return;
}
}
ulog("ERROR: Train widget: Reserved more than MAX_RESERVED_NODES");
}
bool fork_task(struct loop *loop, const char *program, char **argv, const char *name, int *output, pid_t *pid) {
int pipes[2];
if (pipe(pipes) == -1) {
ulog(LLOG_ERROR, "Couldn't create %s pipes: %s\n", name, strerror(errno));
return false;
}
pid_t new_pid = loop_fork(loop);
if (new_pid == -1) {
ulog(LLOG_ERROR, "Couldn't create new %s process: %s\n", name, strerror(errno));
if (close(pipes[0]) == -1)
ulog(LLOG_ERROR, "Failed to close %s read pipe: %s\n", name, strerror(errno));
if (close(pipes[1]) == -1)
ulog(LLOG_ERROR, "Failed to close %s write pipe: %s\n", name, strerror(errno));
return false;
}
if (new_pid == 0) { // We are the child now.
sanity(close(pipes[0]) != -1, "Failed to close %s read pipe in child: %s\n", name, strerror(errno));
sanity(dup2(pipes[1], 1) != -1, "Failed to assign stdout of %s: %s\n", name, strerror(errno));
sanity(close(pipes[1]) != -1, "Failed to close copy of %s write pipe: %s\n", name, strerror(errno));
execv(program, argv);
sanity(false, "Failed to execute %s (%s): %s\n", name, program, strerror(errno));
} else {
if (close(pipes[1]) == -1)
ulog(LLOG_ERROR, "Couldn't close %s write pipe: %s\n", name, strerror(errno));
ulog(LLOG_DEBUG, "Task %s (%s) started with FD %d and PID %d\n", name, program, pipes[0], (int) new_pid);
*output = pipes[0];
*pid = new_pid;
}
return true;
}
/**
* Logs a system error.
*
* This function is thread-safe.
*/
void nplSerror(
const char* fmt, /**< The message format */
...) /**< Arguments referenced by the format */
{
va_list args;
va_start(args, fmt);
lock();
ulog(LOG_ERR, "%s", strerror(errno));
vulog(LOG_ERR, fmt, args);
unlock();
va_end(args);
}
void xfree(void *ptr)
{
if(ptr) {
/* Move the pointer back to its real origin. */
ptr = ((char *)ptr - xalloc_magic);
/* Remove from the running total, and free it. */
xalloc_total_used -= *((size_t *)ptr);
free(ptr);
}
else
ulog(ULOG_WARN, "xfree: passed a NULL pointer.");
}
long
csysdep_size (const char *zfile)
{
struct stat s;
if (stat ((char *) zfile, &s) < 0)
{
if (errno == ENOENT)
return -1;
ulog (LOG_ERROR, "stat (%s): %s", zfile, strerror (errno));
return -2;
}
return s.st_size;
}
void __xcfree(char *file, int line, void *ptr)
{
XALLOC_REC *rec, srch;
if(!xalloc_initialized)
xalloc_init();
if(ptr) {
srch.ptr = ptr;
if((rec = hash_search(xalloc_hash, &srch)) == NULL) {
ulog(ULOG_INFO, "(%s, %d): xcfree: attempted to free bad pointer.\n",
file, line);
return;
}
hash_delete(xalloc_hash, rec);
xar_destroy(rec);
}
else {
ulog(ULOG_INFO, "(%s, %d): xfree: attempted to free NULL pointer.\n",
file, line);
return;
}
xalloc_numfree++;
xcfree(ptr);
}
boolean
fcopy_file (const char *zfrom, const char *zto, boolean fpublic, boolean fmkdirs, boolean fsignals)
{
FILE *efrom;
boolean fret;
efrom = fopen (zfrom, BINREAD);
if (efrom == NULL)
{
ulog (LOG_ERROR, "fopen (%s): %s", zfrom, strerror (errno));
return FALSE;
}
fret = fcopy_open_file (efrom, zto, fpublic, fmkdirs, fsignals);
(void) fclose (efrom);
return fret;
}
DSM_ISUBSET *dsm_isubset(DATASET *dset, unsigned *index, unsigned len)
{
DSM_ISUBSET *isubset;
unsigned sz;
sz = dataset_size(dset);
if(len == 0 || len > sz) {
ulog(ULOG_ERROR, "DSM_ISUBSET: parameters failed sanity check."
"%t(%d == 0 || %d > %d).", len, len, sz);
return(NULL);
}
isubset = xmalloc(sizeof(DSM_ISUBSET));
isubset->dset = dset;
isubset->index = index;
isubset->len = len;
return(isubset);
}
int userlog(char *param)
{
char *prname, *prpid, *grade, *msg;
static char lfn[PATH_MAX], token[14];
int rc;
lfn[0] = '\0';
strncpy(token, strtok(param, ","), 14);
strncpy(token, strtok(NULL, ","), 14);
snprintf(lfn, PATH_MAX, "%s/log/%s", getenv("FTND_ROOT"), token);
prname = strtok(NULL, ",");
prpid = strtok(NULL, ",");
grade = strtok(NULL, ",");
msg = xstrcpy(cldecode(strtok(NULL, ";")));
rc = ulog(lfn, grade, prname, prpid, msg);
free(msg);
return rc;
}
void _masterProcessStatus() {
/* Check if status is expired */
unsigned long now = time(NULL);
if(next_master_refresh_time < now) {
objSds *value = dictFetchValue(master_cache,statusQuery);
if(value) {
sds oldptr = value->ptr;
/* Re-asign the value */
value->ptr = _masterGetStatus();
sdsfree(oldptr);
next_master_refresh_time = now + MASTER_STATUS_REFRESH_PERIOD;
}
else {
ulog(CCACHE_WARNING,"master cache %s not found",statusQuery);
next_master_refresh_time = now + MASTER_STATUS_REFRESH_PERIOD*1000;
}
}
}
void *xmalloc(size_t size)
{
size_t *ptr;
/* Make room to keep the size. */
size += xalloc_magic;
/* Get the memory. */
if(!(ptr = malloc(size)))
ulog(ULOG_FATAL, "xmalloc: failed to get %ld bytes.", (long)size);
/* Assign the size of the segment, and keep a running total. */
*ptr = size;
xalloc_total_used += size;
/* Reset the pointer to the user memory. */
ptr = (size_t *)((char *)ptr + xalloc_magic);
return(ptr);
}
/*
* Logs the currently-accumulated log-messages and resets the message-list for
* the current thread.
*
* This function is thread-safe.
*/
void nplLog(
const int level) /**< The level at which to log the messages. One of
* LOG_ERR, LOG_WARNING, LOG_NOTICE, LOG_INFO, or
* LOG_DEBUG; otherwise, the behavior is undefined. */
{
List* list = getList();
if (NULL != list && NULL != list->last) {
static const unsigned allPrioritiesMask =
LOG_MASK(LOG_ERR) |
LOG_MASK(LOG_WARNING) |
LOG_MASK(LOG_NOTICE) |
LOG_MASK(LOG_INFO) |
LOG_MASK(LOG_DEBUG);
const int priorityMask = LOG_MASK(level);
lock();
if ((priorityMask & allPrioritiesMask) == 0) {
nplError("nplLog(): Invalid logging-level (%d)", level);
}
else if (getulogmask() & priorityMask) {
const Message* msg;
for (msg = list->first; NULL != msg; msg = msg->next) {
/*
* NB: The message is not printed using "ulog(level,
* msg->string)" because "msg->string" might have formatting
* characters in it (e.g., "%") from, for example, a call to
* "s_prod_info()" with a dangerous product-identifier.
*/
ulog(level, "%s", msg->string);
if (msg == list->last)
break;
} /* message loop */
} /* messages should be printed */
unlock();
nplClear();
} /* have messages */
}
void *__xrealloc(char *file, int line, void * ptr, size_t size)
{
XALLOC_REC *rec, srch;
if(!xalloc_initialized)
xalloc_init();
if(ptr) {
srch.ptr = ptr;
if((rec = hash_search(xalloc_hash, &srch)) == NULL) {
ulog(ULOG_INFO, "(%s, %d): xrealloc: attempted to realloc "
"from bad pointer.\n", file, line);
return(NULL);
}
hash_delete(xalloc_hash, rec);
xar_destroy(rec);
}
ptr = xrealloc(ptr, size);
xalloc_numrealloc++, xalloc_id++;
rec = xar_create(file, line, xalloc_id, xrealloc_name, ptr, size);
hash_insert(xalloc_hash, rec);
return(ptr);
}
void *xrealloc(void *old_ptr, size_t size)
{
size_t *new_ptr;
/* If the old pointer is NULL then just do a standard malloc. */
if(!old_ptr)
return(xmalloc(size));
/* If the new size request is zero then just free the old memory. */
if(!size) {
xfree(old_ptr);
return(NULL);
}
/* Get back the pointer that was returned by either malloc() or realloc() */
old_ptr = ((char *)old_ptr - xalloc_magic);
/* Remove the old segment from the running total. */
xalloc_total_used -= *((size_t *)old_ptr);
/* Make room to keep the size. */
size += xalloc_magic;
/* Update the running total. */
xalloc_total_used += size;
/* Get the memory. */
if(!(new_ptr = realloc(old_ptr, size)))
ulog(ULOG_FATAL, "xrealloc: failed to get %ld bytes.", (long)size);
/* Assign the size of the segment, and keep a running total. */
*new_ptr = size;
/* Reset the pointer to the user memory. */
new_ptr = (size_t *)((char *)new_ptr + xalloc_magic);
return((void *)new_ptr);
}
boolean
fsysdep_in_directory (const char *zfile, const char *zdir, boolean fcheck, boolean freadable, const char *zuser)
{
size_t c;
char *zcopy, *zslash;
struct stat s;
if (*zfile != '/')
return FALSE;
c = strlen (zdir);
if (c > 0 && zdir[c - 1] == '/')
c--;
if (strncmp (zfile, zdir, c) != 0
|| (zfile[c] != '/' && zfile[c] != '\0'))
return FALSE;
if (strstr (zfile + c, "/../") != NULL)
return FALSE;
/* If we're not checking access, get out now. */
if (! fcheck)
return TRUE;
zcopy = zbufcpy (zfile);
/* Start checking directories after zdir. Otherwise, we would
require that all directories down to /usr/spool/uucppublic be
publically searchable; they probably are but it should not be a
requirement. */
zslash = zcopy + c;
do
{
char b;
struct stat shold;
b = *zslash;
*zslash = '\0';
shold = s;
if (stat (zcopy, &s) != 0)
{
if (errno != ENOENT)
{
ulog (LOG_ERROR, "stat (%s): %s", zcopy, strerror (errno));
ubuffree (zcopy);
return FALSE;
}
/* If this is the top directory, any problems will be caught
later when we try to open it. */
if (zslash == zcopy + c)
{
ubuffree (zcopy);
return TRUE;
}
/* Go back and check the last directory for read or write
access. */
s = shold;
break;
}
/* If this is not a directory, get out of the loop. */
if (! S_ISDIR (s.st_mode))
break;
/* Make sure the directory is searchable. */
if (! fsuser_access (&s, X_OK, zuser))
{
ulog (LOG_ERROR, "%s: %s", zcopy, strerror (EACCES));
ubuffree (zcopy);
return FALSE;
}
/* If we've reached the end of the string, get out. */
if (b == '\0')
break;
*zslash = b;
}
while ((zslash = strchr (zslash + 1, '/')) != NULL);
/* At this point s holds a stat on the last component of the path.
We must check it for readability or writeability. */
if (! fsuser_access (&s, freadable ? R_OK : W_OK, zuser))
{
ulog (LOG_ERROR, "%s: %s", zcopy, strerror (EACCES));
ubuffree (zcopy);
return FALSE;
}
ubuffree (zcopy);
return TRUE;
}
void upnp_service::map_port( uint16_t local_port )
{
std::string port = fc::variant(local_port).as_string();
my->map_port_complete = my->upnp_thread.async( [=]() {
const char * multicastif = 0;
const char * minissdpdpath = 0;
struct UPNPDev * devlist = 0;
char lanaddr[64];
/* miniupnpc 1.6 */
int error = 0;
devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
struct UPNPUrls urls;
memset( &urls, 0, sizeof(urls) );
struct IGDdatas data;
memset( &data, 0, sizeof(data) );
int r;
r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
bool port_mapping_added = false;
bool port_mapping_added_successfully = false;
if (r == 1)
{
if (true) // TODO config this ? fDiscover)
{
char externalIPAddress[40];
r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
if(r != UPNPCOMMAND_SUCCESS)
wlog("UPnP: GetExternalIPAddress() returned ${code}", ("code", r));
else
{
if(externalIPAddress[0])
{
ulog("UPnP: ExternalIPAddress = ${address}", ("address", externalIPAddress));
my->external_ip = fc::ip::address( std::string(externalIPAddress) );
// AddLocal(CNetAddr(externalIPAddress), LOCAL_UPNP);
}
else
wlog("UPnP: GetExternalIPAddress failed.");
}
}
std::string strDesc = "BitShares 0.0"; // TODO + FormatFullVersion();
// try
{
while(!my->done) // TODO provide way to exit cleanly
{
/* miniupnpc 1.6 */
r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
port.c_str(), port.c_str(), lanaddr, strDesc.c_str(), "TCP", 0, "0");
port_mapping_added = true;
if(r!=UPNPCOMMAND_SUCCESS)
wlog("AddPortMapping(${port}, ${port}, ${addr}) failed with code ${code} (${string})",
("port", port)("addr", lanaddr)("code", r)("string", strupnperror(r)));
else
{
if (!port_mapping_added_successfully)
ulog("UPnP Port Mapping successful");
port_mapping_added_successfully = true;
my->mapped_port = local_port;
}
fc::usleep( fc::seconds(60*20) ); // Refresh every 20 minutes
}
}
// catch (boost::thread_interrupted)
{
if( port_mapping_added )
{
r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port.c_str(), "TCP", 0);
ilog("UPNP_DeletePortMapping() returned : ${r}", ("r",r));
freeUPNPDevlist(devlist); devlist = 0;
FreeUPNPUrls(&urls);
}
// throw;
}
} else {
//printf("No valid UPnP IGDs found\n");
wlog("No valid UPnP IGDs found");
freeUPNPDevlist(devlist); devlist = 0;
if (r != 0)
{
FreeUPNPUrls(&urls);
}
}
}, "upnp::map_port" );
}
