Пример #1
0
/*
 * returns the length of the variable
 */
int v_length(var_t *var) {
  char tmpsb[64];

  switch (var->type) {
  case V_STR:
    return strlen((char *) var->v.p.ptr);
  case V_UDS:
    return uds_length(var);
  case V_HASH:
    return hash_length(var);
  case V_PTR:
    ltostr(var->v.ap.p, tmpsb);
    return strlen(tmpsb);
  case V_INT:
    ltostr(var->v.i, tmpsb);
    return strlen(tmpsb);
  case V_NUM:
    ftostr(var->v.n, tmpsb);
    return strlen(tmpsb);
  case V_ARRAY:
    return var->v.a.size;
  }

  return 1;
}
Пример #2
0
/*
 * returns the length of the variable
 */
int v_length(var_t *var) {
  char tmpsb[64];

  switch (var->type) {
  case V_STR:
    return strlen(var->v.p.ptr);
  case V_MAP:
    return map_length(var);
  case V_PTR:
    ltostr(var->v.ap.p, tmpsb);
    return strlen(tmpsb);
  case V_INT:
    ltostr(var->v.i, tmpsb);
    return strlen(tmpsb);
  case V_NUM:
    ftostr(var->v.n, tmpsb);
    return strlen(tmpsb);
  case V_ARRAY:
    return var->v.a.size;
  case V_REF:
    return v_length(var->v.ref);
  }

  return 1;
}
Пример #3
0
/*
 * returns the string representation of the variable
 */
char *v_str(var_t *arg) {
  char *buffer;
  switch (arg->type) {
  case V_INT:
    buffer = malloc(64);
    ltostr(arg->v.i, buffer);
    break;
  case V_NUM:
    buffer = malloc(64);
    ftostr(arg->v.n, buffer);
    break;
  case V_STR:
    buffer = strdup(arg->v.p.ptr);
    break;
  case V_ARRAY:
  case V_MAP:
    buffer = map_to_str(arg);
    break;
  case V_FUNC:
  case V_PTR:
    buffer = malloc(5);
    strcpy(buffer, "func");
    break;
  default:
    buffer = malloc(1);
    buffer[0] = '\0';
    break;
  }
  return buffer;
}
Пример #4
0
int LD3dsExporter::getMaterial(int colorNumber)
{
	IntIntMap::iterator it = m_colorNumbers.find(colorNumber);

	if (it == m_colorNumbers.end())
	{
		int material = (int)m_colorNumbers.size();
		Lib3dsMaterial *mat = lib3ds_material_new((std::string("ldraw_") +
			ltostr(colorNumber)).c_str());
        lib3ds_file_insert_material(m_file, mat, -1);
		int r, g, b, a;
		LDLPalette *pPalette = m_topModel->getMainModel()->getPalette();
		pPalette->getRGBA(colorNumber, r, g, b, a);
		LDLColorInfo colorInfo = pPalette->getAnyColorInfo(colorNumber);

        mat->diffuse[0] = r / 255.0f;
        mat->diffuse[1] = g / 255.0f;
        mat->diffuse[2] = b / 255.0f;
		mat->transparency = 1.0f - a / 255.0f;
		mat->two_sided = 1;
		if (colorInfo.rubber)
		{
			mat->specular[0] = mat->specular[1] = mat->specular[2] = 0.05f;
		}
		mat->shading = LIB3DS_SHADING_PHONG;
		m_colorNumbers[colorNumber] = material;
		return material;
	}
	else
	{
		return it->second;
	}
}
Пример #5
0
char *                  /* addr of terminating null */
ltostr (
    char *str,          /* output string */
    long val,           /* value to be converted */
    unsigned base)      /* conversion base       */
{
    ldiv_t r;           /* result of val / base */

    if (base > 36)      /* no conversion if wrong base */
    {
        str = '\0';
        return str;
    }
    if (val < 0)    *str++ = '-';
    r = ldiv (labs(val), base);

    /* output digits of val/base first */

    if (r.quot > 0)  str = ltostr (str, r.quot, base);

    /* output last digit */

    *str++ = "0123456789abcdefghijklmnopqrstuvwxyz"[(int)r.rem];
    *str   = '\0';
    return str;
}
Пример #6
0
void dump_binary(void *p, size_t s)
{
    char dump[256+1];
    char temp[256+1];
    unsigned char  uc = 0;
    unsigned short us = 0;
    unsigned int   ui = 0;
    unsigned long  ul = 0;
    int ii;

    memset(dump, 0x00, sizeof(dump));
    memset(temp, 0x00, sizeof(dump));

    switch(s) {
    case 1:
        uc = *(unsigned char  *)p;
        sprintf(dump, "%08s", ltostr(uc, 2));
	break;
    case 2:
        us = *(unsigned short *)p;
        sprintf(dump, "%016s", ultostr(us, 2));
	break;
    case 4:
        ui = *(unsigned int   *)p;
        sprintf(dump, "%032s", ultostr(ui, 2));
	break;
    case 8:
        ul = *(unsigned long  *)p;
        sprintf(dump, "%064s", ultostr(ul, 2));
	break;
    case 16:
        ul = *(unsigned long  *)p;
        sprintf(dump, "%064s", ultostr(ul, 2));
        ul = *(((unsigned long  *)p)+1);
        sprintf(dump+64, "%064s", ultostr(ul, 2));
	break;
    }

    for(ii=0; ii<6; ii++) temp[ii] = ' ';
    for(ii=0; ii<s*8; ii++)
    {
	temp[ii+6] = (ii+1)/10>9 ? 'A' - 10 + (ii+1)/10 : '0' + (ii+1)/10;
    }
    temp[ii+6] = '\0';
    puts(temp);
    for(ii=0; ii<s*8; ii++)
    {
	temp[ii+6] = '0' + ((ii+1)%10);
    }
    temp[ii+6] = '\0';
    puts(temp);
    sprintf(temp, "[%2d] [%s]\n", s, dump);
    puts(temp);
}
Пример #7
0
void write_log(int semid, int logfd, char* log_msg){
    char* prefix = "[Client ";
    char* client_id = ltostr(getpid());
    char* suffix = ": ";
    
    //time_t seconds = time(NULL);
    struct timeval tv;
    gettimeofday(&tv, NULL);
    struct tm* date_time = localtime(&tv.tv_sec);
    char* format = "%d.%m.%y %H:%M:%S.";
    int size = strlen(format) + 6;
    char* date = (char*)malloc((size + 1) * sizeof(char));
    strftime(date, size, format, date_time);
    char* microsecs = ltostr(tv.tv_usec % (1000 * 1000));
    char* postfix = "] ";
    char* postpostfix = "\n";
    char* str_log = (char*)malloc((strlen(log_msg) + strlen(prefix) + strlen(client_id) + strlen(suffix) + 
	strlen(date) + strlen(microsecs) + strlen(postfix) + strlen(postpostfix)) * sizeof(char));
    str_log[0] = 0;
    
    strcat(str_log, prefix);
    strcat(str_log, client_id);
    strcat(str_log, suffix);
    strcat(str_log, date);
    strcat(str_log, microsecs);
    strcat(str_log, postfix);
    strcat(str_log, log_msg);
    strcat(str_log, postpostfix);
    
    struct sembuf sem_oper;
    sem_oper.sem_num = 0;
    sem_oper.sem_flg = 0;
    
    sem_oper.sem_op = -1;
    if(semop(semid, &sem_oper, 1) < 0)
	error_prex("decrease semafor");
    write_from_str(str_log, logfd);
    sem_oper.sem_op = 1;
    if(semop(semid, &sem_oper, 1) < 0)
	error_prex("increase cemafor");
}
Пример #8
0
std::string LD3dsExporter::getMeshName(LDLModel *model, Lib3dsMesh *&pMesh)
{
	std::string modelName;
	std::string meshName = "LDXM_";
	StringIntMap::iterator it;
	int index;

	if (model != NULL)
	{
		char *filename = filenameFromPath(model->getFilename());
		size_t dotSpot;

		modelName = filename;
		dotSpot = modelName.rfind('.');
		delete filename;
		if (dotSpot < modelName.size())
		{
			modelName = modelName.substr(0, dotSpot);
		}
	}
	else
	{
		modelName = "no_name";
	}
	it = m_names.find(modelName);
	if (it == m_names.end())
	{
		index = (int)m_names.size() + 1;
		meshName += ltostr(index);
		pMesh = NULL;
	}
	else
	{
		index = it->second;
		meshName += ltostr(index);
		pMesh = m_meshes[meshName];
	}
	//m_names[modelName] = index;
	return meshName;
}
Пример #9
0
/*
 * converts the variable to string-variable
 */
void v_tostr(var_t *arg) {
  if (arg->type != V_STR) {
    char *tmp;
    int l;

    tmp = tmp_alloc(64);

    switch (arg->type) {
    case V_UDS:
      uds_to_str(arg, tmp, 64);
      uds_free(arg);
      break;
    case V_HASH:
      hash_to_str(arg, tmp, 64);
      hash_free_var(arg);
      break;
    case V_PTR:
      ltostr(arg->v.ap.p, tmp);
      break;
    case V_INT:
      ltostr(arg->v.i, tmp);
      break;
    case V_NUM:
      ftostr(arg->v.n, tmp);
      break;
    default:
      err_varisarray();
      tmp_free(tmp);
      return;
    }

    l = strlen(tmp) + 1;
    arg->type = V_STR;
    arg->v.p.ptr = tmp_alloc(l);
    arg->v.p.size = l;
    strcpy(arg->v.p.ptr, tmp);
    tmp_free(tmp);
  }
}
Пример #10
0
int dump_heap(struct heap **heap_dump, int pid_id)
{
	char dump_file[30];
	char *dump_data = (char*)malloc(100);
	FILE *df = NULL;
	int hs = 0;
	int bytes = 0;
	
	bzero(dump_data,100);
	ptrace(PTRACE_ATTACH, pid_id, NULL, NULL);

	sprintf(dump_file,"%d.dump",pid_id);
	df = fopen(dump_file,"a+");
	if(df == NULL) {
		printf("* Error creating file %s, quitting.\n", dump_file);
		ptrace(PTRACE_DETACH, pid_id, NULL, NULL);
		return -1;
	}

	printf("--------------------------------------------------------------\n");
       	printf("* Dumping memory to %s this can take awhile.\n", dump_file);
	while(hs < heap_structure_size) {
		while(heap_dump[hs]->saddress <= heap_dump[hs]->address) {
			ltostr(dump_data,peekdata(heap_dump[hs]->saddress,pid_id));
			bytes += fwrite(dump_data,1,sizeof(dump_data),df);
			heap_dump[hs]->saddress++;
		}

		printf("* Wrote %d bytes.\n", bytes);
		bytes = 0;
		hs++;
	}

	fclose(df);
	ptrace(PTRACE_DETACH, pid_id, NULL, NULL);
	printf("* Finished.\n");	
	return 0;
}
Пример #11
0
char *to_binary(void *p, size_t s)
{
    unsigned char  uc = 0;
    unsigned short us = 0;
    unsigned int   ui = 0;
    unsigned long  ul = 0;
    static char *buff;

    buff = buff ? buff : malloc(s);
    memset(buff, 0x00, s);

    switch(s) {
    case 1:
        uc = *(unsigned char  *)p;
        sprintf(buff, "%08s", ltostr(uc, 2));
	break;
    case 2:
        us = *(unsigned short *)p;
        sprintf(buff, "%016s", ultostr(us, 2));
	break;
    case 4:
        ui = *(unsigned int   *)p;
        sprintf(buff, "%032s", ultostr(ui, 2));
	break;
    case 8:
        ul = *(unsigned long  *)p;
        sprintf(buff, "%064s", ultostr(ul, 2));
	break;
    case 16:
        ul = *(unsigned long  *)p;
        sprintf(buff, "%064s", ultostr(ul, 2));
        ul = *(((unsigned long  *)p)+1);
        sprintf(buff+64, "%064s", ultostr(ul, 2));
	break;
    }

    return buff;
}
Пример #12
0
static int cgi_create_env(server *srv, connection *con, plugin_data *p, buffer *cgi_handler) {
	pid_t pid;

#ifdef HAVE_IPV6
	char b2[INET6_ADDRSTRLEN + 1];
#endif

	int to_cgi_fds[2];
	int from_cgi_fds[2];
	struct stat st;

#ifndef __WIN32

	if (cgi_handler->used > 1) {
		/* stat the exec file */
		if (-1 == (stat(cgi_handler->ptr, &st))) {
			log_error_write(srv, __FILE__, __LINE__, "sbss",
					"stat for cgi-handler", cgi_handler,
					"failed:", strerror(errno));
			return -1;
		}
	}

	if (pipe(to_cgi_fds)) {
		log_error_write(srv, __FILE__, __LINE__, "ss", "pipe failed:", strerror(errno));
		return -1;
	}

	if (pipe(from_cgi_fds)) {
		log_error_write(srv, __FILE__, __LINE__, "ss", "pipe failed:", strerror(errno));
		return -1;
	}

	/* fork, execve */
	switch (pid = fork()) {
	case 0: {
		/* child */
		char **args;
		int argc;
		int i = 0;
		char buf[32];
		size_t n;
		char_array env;
		char *c;
		const char *s;
		server_socket *srv_sock = con->srv_socket;

		/* move stdout to from_cgi_fd[1] */
		close(STDOUT_FILENO);
		dup2(from_cgi_fds[1], STDOUT_FILENO);
		close(from_cgi_fds[1]);
		/* not needed */
		close(from_cgi_fds[0]);

		/* move the stdin to to_cgi_fd[0] */
		close(STDIN_FILENO);
		dup2(to_cgi_fds[0], STDIN_FILENO);
		close(to_cgi_fds[0]);
		/* not needed */
		close(to_cgi_fds[1]);

		/* HACK:
		 * this is not nice, but it works
		 *
		 * we feed the stderr of the CGI to our errorlog, if possible
		 */
		if (srv->errorlog_mode == ERRORLOG_FILE) {
			close(STDERR_FILENO);
			dup2(srv->errorlog_fd, STDERR_FILENO);
		}

		/* create environment */
		env.ptr = NULL;
		env.size = 0;
		env.used = 0;

		cgi_env_add(&env, CONST_STR_LEN("SERVER_SOFTWARE"), CONST_STR_LEN(PACKAGE_NAME"/"PACKAGE_VERSION));

		if (!buffer_is_empty(con->server_name)) {
			cgi_env_add(&env, CONST_STR_LEN("SERVER_NAME"), CONST_BUF_LEN(con->server_name));
		} else {
#ifdef HAVE_IPV6
			s = inet_ntop(srv_sock->addr.plain.sa_family,
				      srv_sock->addr.plain.sa_family == AF_INET6 ?
				      (const void *) &(srv_sock->addr.ipv6.sin6_addr) :
				      (const void *) &(srv_sock->addr.ipv4.sin_addr),
				      b2, sizeof(b2)-1);
#else
			s = inet_ntoa(srv_sock->addr.ipv4.sin_addr);
#endif
			cgi_env_add(&env, CONST_STR_LEN("SERVER_NAME"), s, strlen(s));
		}
		cgi_env_add(&env, CONST_STR_LEN("GATEWAY_INTERFACE"), CONST_STR_LEN("CGI/1.1"));

		s = get_http_version_name(con->request.http_version);

		cgi_env_add(&env, CONST_STR_LEN("SERVER_PROTOCOL"), s, strlen(s));

		ltostr(buf,
#ifdef HAVE_IPV6
			ntohs(srv_sock->addr.plain.sa_family == AF_INET6 ? srv_sock->addr.ipv6.sin6_port : srv_sock->addr.ipv4.sin_port)
#else
			ntohs(srv_sock->addr.ipv4.sin_port)
#endif
			);
		cgi_env_add(&env, CONST_STR_LEN("SERVER_PORT"), buf, strlen(buf));

#ifdef HAVE_IPV6
		s = inet_ntop(srv_sock->addr.plain.sa_family,
			      srv_sock->addr.plain.sa_family == AF_INET6 ?
			      (const void *) &(srv_sock->addr.ipv6.sin6_addr) :
			      (const void *) &(srv_sock->addr.ipv4.sin_addr),
			      b2, sizeof(b2)-1);
#else
		s = inet_ntoa(srv_sock->addr.ipv4.sin_addr);
#endif
		cgi_env_add(&env, CONST_STR_LEN("SERVER_ADDR"), s, strlen(s));

		s = get_http_method_name(con->request.http_method);
		cgi_env_add(&env, CONST_STR_LEN("REQUEST_METHOD"), s, strlen(s));

		if (!buffer_is_empty(con->request.pathinfo)) {
			cgi_env_add(&env, CONST_STR_LEN("PATH_INFO"), CONST_BUF_LEN(con->request.pathinfo));
		}
		cgi_env_add(&env, CONST_STR_LEN("REDIRECT_STATUS"), CONST_STR_LEN("200"));
		if (!buffer_is_empty(con->uri.query)) {
			cgi_env_add(&env, CONST_STR_LEN("QUERY_STRING"), CONST_BUF_LEN(con->uri.query));
		}
		if (!buffer_is_empty(con->request.orig_uri)) {
			cgi_env_add(&env, CONST_STR_LEN("REQUEST_URI"), CONST_BUF_LEN(con->request.orig_uri));
		}


#ifdef HAVE_IPV6
		s = inet_ntop(con->dst_addr.plain.sa_family,
			      con->dst_addr.plain.sa_family == AF_INET6 ?
			      (const void *) &(con->dst_addr.ipv6.sin6_addr) :
			      (const void *) &(con->dst_addr.ipv4.sin_addr),
			      b2, sizeof(b2)-1);
#else
		s = inet_ntoa(con->dst_addr.ipv4.sin_addr);
#endif
		cgi_env_add(&env, CONST_STR_LEN("REMOTE_ADDR"), s, strlen(s));

		ltostr(buf,
#ifdef HAVE_IPV6
			ntohs(con->dst_addr.plain.sa_family == AF_INET6 ? con->dst_addr.ipv6.sin6_port : con->dst_addr.ipv4.sin_port)
#else
			ntohs(con->dst_addr.ipv4.sin_port)
#endif
			);
		cgi_env_add(&env, CONST_STR_LEN("REMOTE_PORT"), buf, strlen(buf));

		if (!buffer_is_empty(con->authed_user)) {
			cgi_env_add(&env, CONST_STR_LEN("REMOTE_USER"),
				    CONST_BUF_LEN(con->authed_user));
		}

		/* request.content_length < SSIZE_MAX, see request.c */
		ltostr(buf, con->request.content_length);
		cgi_env_add(&env, CONST_STR_LEN("CONTENT_LENGTH"), buf, strlen(buf));
		cgi_env_add(&env, CONST_STR_LEN("SCRIPT_FILENAME"), CONST_BUF_LEN(con->physical.path));
		cgi_env_add(&env, CONST_STR_LEN("SCRIPT_NAME"), CONST_BUF_LEN(con->uri.path));
		cgi_env_add(&env, CONST_STR_LEN("DOCUMENT_ROOT"), CONST_BUF_LEN(con->physical.doc_root));

		/* for valgrind */
		if (NULL != (s = getenv("LD_PRELOAD"))) {
			cgi_env_add(&env, CONST_STR_LEN("LD_PRELOAD"), s, strlen(s));
		}

		if (NULL != (s = getenv("LD_LIBRARY_PATH"))) {
			cgi_env_add(&env, CONST_STR_LEN("LD_LIBRARY_PATH"), s, strlen(s));
		}
#ifdef __CYGWIN__
		/* CYGWIN needs SYSTEMROOT */
		if (NULL != (s = getenv("SYSTEMROOT"))) {
			cgi_env_add(&env, CONST_STR_LEN("SYSTEMROOT"), s, strlen(s));
		}
#endif

		for (n = 0; n < con->request.headers->used; n++) {
			data_string *ds;

			ds = (data_string *)con->request.headers->data[n];

			if (ds->value->used && ds->key->used) {
				size_t j;

				buffer_reset(p->tmp_buf);

				if (0 != strcasecmp(ds->key->ptr, "CONTENT-TYPE")) {
					buffer_copy_string(p->tmp_buf, "HTTP_");
					p->tmp_buf->used--; /* strip \0 after HTTP_ */
				}

				buffer_prepare_append(p->tmp_buf, ds->key->used + 2);

				for (j = 0; j < ds->key->used - 1; j++) {
					char cr = '_';
					if (light_isalpha(ds->key->ptr[j])) {
						/* upper-case */
						cr = ds->key->ptr[j] & ~32;
					} else if (light_isdigit(ds->key->ptr[j])) {
						/* copy */
						cr = ds->key->ptr[j];
					}
					p->tmp_buf->ptr[p->tmp_buf->used++] = cr;
				}
				p->tmp_buf->ptr[p->tmp_buf->used++] = '\0';

				cgi_env_add(&env, CONST_BUF_LEN(p->tmp_buf), CONST_BUF_LEN(ds->value));
			}
		}

		for (n = 0; n < con->environment->used; n++) {
			data_string *ds;

			ds = (data_string *)con->environment->data[n];

			if (ds->value->used && ds->key->used) {
				size_t j;

				buffer_reset(p->tmp_buf);

				buffer_prepare_append(p->tmp_buf, ds->key->used + 2);

				for (j = 0; j < ds->key->used - 1; j++) {
					p->tmp_buf->ptr[p->tmp_buf->used++] =
						isalpha((unsigned char)ds->key->ptr[j]) ?
						toupper((unsigned char)ds->key->ptr[j]) : '_';
				}
				p->tmp_buf->ptr[p->tmp_buf->used++] = '\0';

				cgi_env_add(&env, CONST_BUF_LEN(p->tmp_buf), CONST_BUF_LEN(ds->value));
			}
		}

		if (env.size == env.used) {
			env.size += 16;
			env.ptr = realloc(env.ptr, env.size * sizeof(*env.ptr));
		}

		env.ptr[env.used] = NULL;

		/* set up args */
		argc = 3;
		args = malloc(sizeof(*args) * argc);
		i = 0;

		if (cgi_handler->used > 1) {
			args[i++] = cgi_handler->ptr;
		}
		args[i++] = con->physical.path->ptr;
		args[i++] = NULL;

		/* search for the last / */
		if (NULL != (c = strrchr(con->physical.path->ptr, '/'))) {
			*c = '\0';

			/* change to the physical directory */
			if (-1 == chdir(con->physical.path->ptr)) {
				log_error_write(srv, __FILE__, __LINE__, "ssb", "chdir failed:", strerror(errno), con->physical.path);
			}
			*c = '/';
		}

		/* we don't need the client socket */
		for (i = 3; i < 256; i++) {
			if (i != srv->errorlog_fd) close(i);
		}

		/* exec the cgi */
		execve(args[0], args, env.ptr);

		log_error_write(srv, __FILE__, __LINE__, "sss", "CGI failed:", strerror(errno), args[0]);

		/* */
		SEGFAULT();
		break;
	}
	case -1:
		/* error */
		log_error_write(srv, __FILE__, __LINE__, "ss", "fork failed:", strerror(errno));
		break;
	default: {
		handler_ctx *hctx;
		/* father */

		close(from_cgi_fds[1]);
		close(to_cgi_fds[0]);

		if (con->request.content_length) {
			chunkqueue *cq = con->request_content_queue;
			chunk *c;

			assert(chunkqueue_length(cq) == (off_t)con->request.content_length);

			/* there is content to send */
			for (c = cq->first; c; c = cq->first) {
				int r = 0;

				/* copy all chunks */
				switch(c->type) {
				case FILE_CHUNK:

					if (c->file.mmap.start == MAP_FAILED) {
						if (-1 == c->file.fd &&  /* open the file if not already open */
						    -1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY))) {
							log_error_write(srv, __FILE__, __LINE__, "ss", "open failed: ", strerror(errno));

							close(from_cgi_fds[0]);
							close(to_cgi_fds[1]);
							return -1;
						}

						c->file.mmap.length = c->file.length;

						if (MAP_FAILED == (c->file.mmap.start = mmap(0,  c->file.mmap.length, PROT_READ, MAP_SHARED, c->file.fd, 0))) {
							log_error_write(srv, __FILE__, __LINE__, "ssbd", "mmap failed: ",
									strerror(errno), c->file.name,  c->file.fd);

							close(from_cgi_fds[0]);
							close(to_cgi_fds[1]);
							return -1;
						}

						close(c->file.fd);
						c->file.fd = -1;

						/* chunk_reset() or chunk_free() will cleanup for us */
					}

					if ((r = write(to_cgi_fds[1], c->file.mmap.start + c->offset, c->file.length - c->offset)) < 0) {
						switch(errno) {
						case ENOSPC:
							con->http_status = 507;

							break;
						default:
							con->http_status = 403;
							break;
						}
					}
					break;
				case MEM_CHUNK:
					if ((r = write(to_cgi_fds[1], c->mem->ptr + c->offset, c->mem->used - c->offset - 1)) < 0) {
						switch(errno) {
						case ENOSPC:
							con->http_status = 507;

							break;
						default:
							con->http_status = 403;
							break;
						}
					}
					break;
				case UNUSED_CHUNK:
					break;
				}

				if (r > 0) {
					c->offset += r;
					cq->bytes_out += r;
				} else {
					break;
				}
				chunkqueue_remove_finished_chunks(cq);
			}
		}

		close(to_cgi_fds[1]);

		/* register PID and wait for them asyncronously */
		con->mode = p->id;
		buffer_reset(con->physical.path);

		hctx = cgi_handler_ctx_init();

		hctx->remote_conn = con;
		hctx->plugin_data = p;
		hctx->pid = pid;
		hctx->fd = from_cgi_fds[0];
		hctx->fde_ndx = -1;

		con->plugin_ctx[p->id] = hctx;

		fdevent_register(srv->ev, hctx->fd, cgi_handle_fdevent, hctx);
		fdevent_event_add(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_IN);

		if (-1 == fdevent_fcntl_set(srv->ev, hctx->fd)) {
			log_error_write(srv, __FILE__, __LINE__, "ss", "fcntl failed: ", strerror(errno));

			fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
			fdevent_unregister(srv->ev, hctx->fd);

			log_error_write(srv, __FILE__, __LINE__, "sd", "cgi close:", hctx->fd);

			close(hctx->fd);

			cgi_handler_ctx_free(hctx);

			con->plugin_ctx[p->id] = NULL;

			return -1;
		}

		break;
	}
	}

	return 0;
#else
	return -1;
#endif
}
Пример #13
0
/*
 * add two variables
 * result = a + b
 */
void v_add(var_t *result, var_t *a, var_t *b) {
  char tmpsb[64];

  if (a->type == V_STR && b->type == V_STR) {
    result->type = V_STR;
    result->v.p.ptr = malloc(strlen(a->v.p.ptr) +
                                        strlen(b->v.p.ptr) + 1);
    strcpy(result->v.p.ptr, a->v.p.ptr);
    strcat(result->v.p.ptr, b->v.p.ptr);
    result->v.p.size = strlen(result->v.p.ptr) + 1;
    return;
  } else if (a->type == V_INT && b->type == V_INT) {
    result->type = V_INT;
    result->v.i = a->v.i + b->v.i;
    return;
  } else if (a->type == V_NUM && b->type == V_NUM) {
    result->type = V_NUM;
    result->v.n = a->v.n + b->v.n;
    return;
  } else if (a->type == V_NUM && b->type == V_INT) {
    result->type = V_NUM;
    result->v.n = a->v.n + b->v.i;
    return;
  } else if (a->type == V_INT && b->type == V_NUM) {
    result->type = V_NUM;
    result->v.n = a->v.i + b->v.n;
    return;
  } else if (a->type == V_STR && (b->type == V_INT || b->type == V_NUM)) {
    if (is_number(a->v.p.ptr)) {
      result->type = V_NUM;
      if (b->type == V_INT) {
        result->v.n = b->v.i + v_getval(a);
      } else {
        result->v.n = b->v.n + v_getval(a);
      }
    } else {
      result->type = V_STR;
      result->v.p.ptr = (char *)malloc(strlen(a->v.p.ptr) + 64);
      strcpy(result->v.p.ptr, a->v.p.ptr);
      if (b->type == V_INT) {
        ltostr(b->v.i, tmpsb);
      } else {
        ftostr(b->v.n, tmpsb);
      }
      strcat(result->v.p.ptr, tmpsb);
      result->v.p.size = strlen(result->v.p.ptr) + 1;
    }
  } else if ((a->type == V_INT || a->type == V_NUM) && b->type == V_STR) {
    if (is_number(b->v.p.ptr)) {
      result->type = V_NUM;
      if (a->type == V_INT) {
        result->v.n = a->v.i + v_getval(b);
      } else {
        result->v.n = a->v.n + v_getval(b);
      }
    } else {
      result->type = V_STR;
      result->v.p.ptr = (char *)malloc(strlen(b->v.p.ptr) + 64);
      if (a->type == V_INT) {
        ltostr(a->v.i, tmpsb);
      } else {
        ftostr(a->v.n, tmpsb);
      }
      strcpy(result->v.p.ptr, tmpsb);
      strcat(result->v.p.ptr, b->v.p.ptr);
      result->v.p.size = strlen(result->v.p.ptr) + 1;
    }
  }
}
Пример #14
0
char *createPresenceMsg(int state, char *text, 
                        char *to, char *from, int priority){
  char *presText = NULL;
  int buffersize = 0;
  char *tmp = NULL;
  int ret = 0;
  xmlDocPtr doc = NULL;
  xmlNodePtr root_node = NULL;
  xmlChar *xmlbuff = NULL;

  switch(state){
    case PRES_CHAT:
      presText="chat";
      break;
    case PRES_DND:
      presText="dnd";
      break;
    case PRES_AWAY:
      presText="away";
      break;
    case PRES_XA:
      presText="xa";
      break;
    case PRES_UNAVAILABLE:
      presText="unavailable";
      break;
  }

  /* rfc3921 says priority has to be bigger than -129 and lower than 128 */
  if(priority != 0 && priority >= -128 && priority <= 127){
    tmp = malloc(sizeof(size_t)*8+1);
    if(tmp){
      ret=ltostr(priority,10,tmp,sizeof(size_t)*8+1);
      if(ret != 0)
        tmp=NULL;
    }
  }
  
  doc = xmlNewDoc(BAD_CAST "1.0");
  root_node = xmlNewNode(NULL, BAD_CAST "presence");
  xmlDocSetRootElement(doc, root_node);
  xmlNewProp(root_node, BAD_CAST "xml:lang", BAD_CAST "en");

  if(state == PRES_UNAVAILABLE)
    xmlNewProp(root_node, BAD_CAST "type", BAD_CAST presText);
  if(presText && state != PRES_UNAVAILABLE)
    xmlNewChild(root_node, NULL, BAD_CAST "show", BAD_CAST presText);
  if(to)
    if(strlen(to)>0)
      xmlNewProp(root_node, BAD_CAST "to", BAD_CAST to);
  if(from)
    if(strlen(from)>0)
      xmlNewProp(root_node, BAD_CAST "from", BAD_CAST from);
  if(text)
    if(strlen(text)>0 && state != PRES_AVAILABLE)
      xmlNewChild(root_node, NULL, BAD_CAST "status", BAD_CAST text);
  if(state != PRES_UNAVAILABLE){
    if(tmp){
      xmlNewChild(root_node, NULL, BAD_CAST "priority", BAD_CAST tmp);
      free(tmp);
    }
  }
  
  xmlDocDumpFormatMemory(doc, &xmlbuff, &buffersize, 1);
  xmlFreeDoc(doc);
  xmlCleanupParser();
  xmlMemoryDump();
  return (char *)xmlbuff;
}
Пример #15
0
/*********************** xitoa.c ***************************/ 
char *_itoa(int i) 
{
	return ltostr((long) i, 10);
} 
Пример #16
0
/*
 * add two variables
 * result = a + b
 */
void v_add(var_t *result, var_t *a, var_t *b) {
  char tmpsb[INT_STR_LEN];

  if (a->type == V_STR && b->type == V_STR) {
    int length = strlen(a->v.p.ptr) + strlen(b->v.p.ptr);
    result->type = V_STR;
    result->v.p.ptr = malloc(length + 1);
    strcpy(result->v.p.ptr, a->v.p.ptr);
    strcat(result->v.p.ptr, b->v.p.ptr);
    result->v.p.ptr[length] = '\0';
    result->v.p.length = length + 1;
    return;
  } else if (a->type == V_INT && b->type == V_INT) {
    result->type = V_INT;
    result->v.i = a->v.i + b->v.i;
    return;
  } else if (a->type == V_NUM && b->type == V_NUM) {
    result->type = V_NUM;
    result->v.n = a->v.n + b->v.n;
    return;
  } else if (a->type == V_NUM && b->type == V_INT) {
    result->type = V_NUM;
    result->v.n = a->v.n + b->v.i;
    return;
  } else if (a->type == V_INT && b->type == V_NUM) {
    result->type = V_NUM;
    result->v.n = a->v.i + b->v.n;
    return;
  } else if (a->type == V_STR && (b->type == V_INT || b->type == V_NUM)) {
    if (is_number(a->v.p.ptr)) {
      result->type = V_NUM;
      if (b->type == V_INT) {
        result->v.n = b->v.i + v_getval(a);
      } else {
        result->v.n = b->v.n + v_getval(a);
      }
    } else {
      result->type = V_STR;
      result->v.p.ptr = (char *)malloc(strlen(a->v.p.ptr) + INT_STR_LEN);
      strcpy(result->v.p.ptr, a->v.p.ptr);
      if (b->type == V_INT) {
        ltostr(b->v.i, tmpsb);
      } else {
        ftostr(b->v.n, tmpsb);
      }
      strcat(result->v.p.ptr, tmpsb);
      result->v.p.length = strlen(result->v.p.ptr) + 1;
    }
  } else if ((a->type == V_INT || a->type == V_NUM) && b->type == V_STR) {
    if (is_number(b->v.p.ptr)) {
      result->type = V_NUM;
      if (a->type == V_INT) {
        result->v.n = a->v.i + v_getval(b);
      } else {
        result->v.n = a->v.n + v_getval(b);
      }
    } else {
      result->type = V_STR;
      result->v.p.ptr = (char *)malloc(strlen(b->v.p.ptr) + INT_STR_LEN);
      if (a->type == V_INT) {
        ltostr(a->v.i, tmpsb);
      } else {
        ftostr(a->v.n, tmpsb);
      }
      strcpy(result->v.p.ptr, tmpsb);
      strcat(result->v.p.ptr, b->v.p.ptr);
      result->v.p.length = strlen(result->v.p.ptr) + 1;
    }
  } else if (b->type == V_MAP) {
    char *map = map_to_str(b);
    v_set(result, a);
    v_strcat(result, map);
    free(map);
  }
}