Beispiel #1
0
/*!
  @brief   Return the suffix part of a path.
  @ingroup system_name
  @param   path Pathname.
  @return  Suffix part (pointer to internal buffer).
*/
char *
v_suffix(char *path)
{
    char *cp = strrchr(path, '.');
    static vbuffer *b = NULL;

    vb_init(b);

    if (cp != NULL)
        while (*cp != '\0')
            vb_putc(b, *cp++);

    return vb_get(b);
}
Beispiel #2
0
/*!
  @brief   Return the directory part of a path.
  @ingroup system_name
  @param   path Pathname.
  @return  Directory part (pointer to internal buffer).
*/
char *
v_dirname(char *path)
{
    char *cp = strrchr(path, V_PATHSEP[0]);
    static vbuffer *b = NULL;

    vb_init(b);

    if (cp == path)
        vb_puts(b, V_PATHSEP);
    else if (cp == NULL)
        vb_putc(b, '.');
    else while (path != cp)
        vb_putc(b, *path++);

    return vb_get(b);
}
Beispiel #3
0
/*!
  @brief   Return the filename part of a path.
  @ingroup system_name
  @param   path Pathname.
  @return  Filename part (pointer to internal buffer).
*/
char *
v_filename(char *path)
{
    char *cp = strrchr(path, V_PATHSEP[0]);
    static vbuffer *b = NULL;

    vb_init(b);

    if (cp == NULL)
        cp = path;
    else
        cp++;

    while (*cp != '\0')
        vb_putc(b, *cp++);

    return vb_get(b);
}
Beispiel #4
0
/* String version of fcatv. */
char *
scatv(const char *s, char *buf, size_t len)
{
    char c;
    varbuf_t r;

    vb_init(&r);
    while ((c = *s++)) {

	/* Expand this character. */
	switch (c) {
	case '\n':
	    vb_appends(&r, "\\n");
	    break;
	case '\t':
	    vb_appends(&r, "\\t");
	    break;
	case '\b':
	    vb_appends(&r, "\\b");
	    break;
	default:
	    if ((c & 0x7f) < ' ') {
		vb_appendf(&r, "\\%03o", c & 0xff);
	    } else {
		vb_append(&r, &c, 1);
	    }
	    break;
	}
    }

    /* Copy what fits. */
    (void) snprintf(buf, len, "%s", vb_buf(&r));
    vb_free(&r);

    return buf;
}
Beispiel #5
0
/**
 * New inbound connection for httpd.
 *
 * @param[in] fd	socket file descriptor
 * @param[in] id	I/O ID
 */
void
hio_connection(iosrc_t fd, ioid_t id)
{
    socket_t t;
    union {
	struct sockaddr sa;
	struct sockaddr_in sin;
#if defined(X3270_IPV6) /*[*/
	struct sockaddr_in6 sin6;
#endif /*]*/
    } sa;
    socklen_t len;
    char hostbuf[128];
    session_t *session;

    len = sizeof(sa);
    t = accept(listen_s, &sa.sa, &len);
    if (t == INVALID_SOCKET) {
	vtrace("httpd accept error: %s%s\n", socket_errtext(),
		(socket_errno() == SE_EWOULDBLOCK)? " (harmless)": "");
	return;
    }
    if (n_sessions >= N_SESSIONS) {
	vtrace("Too many connections.\n");
	SOCK_CLOSE(t);
	return;
    }

    session = Malloc(sizeof(session_t));
    memset(session, 0, sizeof(session_t));
    vb_init(&session->pending.result);
    session->s = t;
#if defined(_WIN32) /*[*/
    session->event = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (session->event == NULL) {
	vtrace("httpd: can't create socket handle\n");
	SOCK_CLOSE(t);
	Free(session);
	return;
    }
    if (WSAEventSelect(session->s, session->event, FD_READ | FD_CLOSE) != 0) {
	vtrace("httpd: Can't set socket handle events\n");
	CloseHandle(session->event);
	SOCK_CLOSE(t);
	Free(session);
	return;
    }
#endif /*]*/
    if (sa.sa.sa_family == AF_INET) {
	session->dhandle = httpd_new(session,
		lazyaf("%s:%u",
		    inet_ntop(AF_INET, &sa.sin.sin_addr, hostbuf,
			sizeof(hostbuf)),
		    ntohs(sa.sin.sin_port)));
    }
#if defined(X3270_IPV6) /*[*/
    else if (sa.sa.sa_family == AF_INET6) {
	session->dhandle = httpd_new(session,
		lazyaf("%s:%u",
		    inet_ntop(AF_INET6, &sa.sin6.sin6_addr, hostbuf,
			sizeof(hostbuf)),
		    ntohs(sa.sin6.sin6_port)));
    }
#endif /*]*/
    else {
	session->dhandle = httpd_new(session, "???");
    }
#if !defined(_WIN32) /*[*/
    session->ioid = AddInput(t, hio_socket_input);
#else /*][*/
    session->ioid = AddInput(session->event, hio_socket_input);
#endif /*]*/

    /* Set the timeout for the first line of input. */
    session->toid = AddTimeOut(IDLE_MAX * 1000, hio_timeout);

    llist_insert_before(&session->link, sessions.next);
    n_sessions++;
}
Beispiel #6
0
static int
copy_recipients(FILE *fp_in, FILE *fp_ctl, FILE *fp_out)
{
	assert(fp_in);
	assert(fp_ctl);

	size_t keep = 0;
	var_buf vb;
	if (vb_init(&vb))
	{
		(*do_report)(LOG_ALERT, "MEMORY FAULT");
		return -1;
	}

	size_t count = 0;
	for (;;)
	{
		char *p = vb_fgets(&vb, keep, fp_in);
		char *eol = p? strchr(p, '\n'): NULL;

		if (eol == NULL)
		{
			if (verbose)
				(*do_report)(LOG_ERR, "header too long? %s", vb_what(&vb, fp_in));
			vb_clean(&vb);
			return -1;
		}

		int const next = eol > p? fgetc(fp_in): '\n';
		int const cont = next != EOF && next != '\n';
		char *const start = vb.buf;
		keep = eol - start + 1;
		if (cont && isspace(next)) // wrapped
		{
			*++eol = next;
			++keep;
			continue;
		}

		/*
		* full field is in buffer
		*/
		if (fp_out && fwrite(start, 1, keep, fp_out) != keep)
		{
			(*do_report)(LOG_CRIT, "copy error: %s", strerror(errno));
			vb_clean(&vb);
			return -1;
		}
		
		p = start;
		*eol = 0;

		size_t len = 0;
		int ch;
		while ((ch = *(unsigned char*)p) != 0 && ch != ':')
		{
			if (isalnum(ch))
			{
				if (len < 3)
				{
					*p = tolower(ch);
					++len;
				}
				else
					break;
			}
			++p;
		}

		if (ch == ':')
		{
			if (len == 3 && strncmp(start, "bcc", 3) == 0 ||
				len == 2 &&
					(strncmp(start, "to", 2) == 0 || strncmp(start, "cc", 2) == 0))
			{
				unsigned const max_rcpts = keep/7; // [email protected],
				unsigned rcpts = 0;
				unsigned char *user, *domain, *pcont = NULL;
				int err = 0;
				char *err_report = strdup(++p);
				static char const data_lost[] = "--*DATA LOST*--";

				while (rcpts++ < max_rcpts)
				{
					err = dkim_mail_parse_c(p, &user, &domain, &pcont);

					if (err)
					{
						if (verbose)
							(*do_report)(LOG_ERR,
								"unable to parse address %u of %s (err=%d)",
								rcpts, err_report? err_report: data_lost, err);
						break;
					}
					else if (user == NULL || *user == 0)
					{
						if (verbose >= 8)
							(*do_report)(LOG_DEBUG,
								"no user in address %u of %s",
								rcpts, err_report? err_report: data_lost);
					}
					else if (domain == NULL || *domain == 0)
					{
						fprintf(fp_ctl, "r%s\n", user);
						++count;
					}
					else
					{
						fprintf(fp_ctl, "r%s@%s\n", user, domain);
						++count;
					}

					if (pcont == NULL || *pcont == 0)
						break;

					p = pcont;
					pcont = NULL;
				}

				if (verbose && rcpts >= max_rcpts && err == 0 && *p)
					(*do_report)(LOG_DEBUG,
						"stuck after %u/%u address(es) of %s (%s)",
						rcpts, max_rcpts, err_report? err_report: data_lost, pcont);

				free(err_report);
			}
		}

		if (!cont)
			break;

		start[0] = next;
		keep = 1;
	}

	vb_clean(&vb);
	return count == 0;
}
Beispiel #7
0
sageContext *
sage_open (int db_flag,
	   int red_size, int green_size, int blue_size,
	   int alpha_size, int depth_size, int stencil_size)
{
    const char *str;
    sageContext *ctx;

    if (hardware < 0) {
	goto exit_error;
    }

    /* Create context */
    ctx = malloc(sizeof(sageContext));
    if (ctx == NULL) {
	goto exit_error;
    }
    ctx->gr_ctx = 0;

    /* Choose a visual */
    ctx->fmt = findPixelFormat(&red_size, &green_size, &blue_size,
			       &alpha_size, &depth_size, &stencil_size);
    fb_color = red_size + green_size + blue_size;
    fb_alpha = alpha_size;

    /* Initialize the core */
    if (ctx_init(db_flag,
		 red_size, green_size, blue_size,
		 alpha_size, depth_size, stencil_size) != 0) {
	goto exit_error1;
    }

    /* Set driver capabilities */
    allow_texuma      = hwext_texuma && !YES("3dfx.disable.texuma");
    allow_texmirror   = hwext_texmirror && !YES("3dfx.disable.texmirror");
    allow_fogcoord    = hwext_fogcoord && !YES("3dfx.disable.fogcoord");
    allow_32bpt       = (fb_color == 24 && hwext_texfmt) && !YES("3dfx.disable.32bpt");
    allow_blendsquare = (hardware >= GR_SSTTYPE_Voodoo4) && !YES("3dfx.disable.blendsquare");
    allow_combine     = GL_TRUE && !YES("3dfx.disable.combine");
    allow_multitex    = (getInteger(GR_NUM_TMU) > 1) && !YES("3dfx.disable.multitex");

    allow_compressed = atoi(cfg_get("3dfx.texture.compression", "3"));
    if (hardware < GR_SSTTYPE_Voodoo4) {
	allow_compressed &= ~2;
    }
    if (!ctx_texcodec) {
	allow_compressed &= ~1;
    }

    if (hardware < GR_SSTTYPE_Voodoo4) {
	allow_combine = -allow_combine;
    }

    /* Update core with driver capabilities */
    ctx_const_max_texture_size = getInteger(GR_MAX_TEXTURE_SIZE);
    ctx_const_max_texture_units = allow_multitex ? 2 : 1;

    max_texture_levels = 0;
    while ((GLuint)(1 << max_texture_levels) < ctx_const_max_texture_size) {
	max_texture_levels++;
    }
    ctx_const_max_lod_bias = max_texture_levels;

    str = cfg_get("3dfx.maxlod", NULL);
    if (str != NULL) {
	ctx_const_max_texture_size = 1 << atoi(str);
    }

    /* Finish driver setup */
    tex_bound_mask = (hardware < GR_SSTTYPE_Banshee) ? 0x1fffff : -1U;

    if (tm_init() != 0) {
	goto exit_error2;
    }

    if (vb_init() != 0) {
	goto exit_error3;
    }

    fogtable = malloc(getInteger(GR_FOG_TABLE_ENTRIES) * sizeof(GrFog_t));
    if (fogtable == NULL) {
	goto exit_error4;
    }

    /* XXX getInteger(GR_GLIDE_STATE_SIZE) */

    drv_multipass = drv_multipass_none;
    init_tri_pointers();

    /* Finish core setup */
    ext_set("GL_EXT_texture_env_add", GL_TRUE);
    ext_set("GL_EXT_texture_edge_clamp", GL_TRUE);
    ext_set("GL_EXT_compiled_vertex_array", GL_TRUE);
    ext_set("GL_EXT_blend_func_separate", GL_TRUE);
    ext_set("GL_EXT_texture_lod_bias", GL_TRUE);
    if (allow_multitex) {
	ext_set("GL_ARB_multitexture", GL_TRUE);
    }
    if (allow_fogcoord) {
	ext_set("GL_EXT_fog_coord", GL_TRUE);
    }
    if (allow_texmirror) {
	ext_set("GL_ARB_texture_mirrored_repeat", GL_TRUE);
    }
    if (stencil_size) {
	ext_set("GL_EXT_stencil_wrap", GL_TRUE);
    }
    if (allow_blendsquare) {
	ext_set("GL_NV_blend_square", GL_TRUE);
    }
    if (allow_combine) {
	ext_set("GL_ARB_texture_env_combine", GL_TRUE);
	ext_set("GL_EXT_texture_env_combine", GL_TRUE);
    }
    if (allow_compressed) {
	ext_set("GL_ARB_texture_compression", GL_TRUE);
	ext_set("GL_EXT_texture_compression_s3tc", GL_TRUE);
	ext_set("GL_3DFX_texture_compression_FXT1", GL_TRUE);
	ext_set("GL_S3_s3tc", GL_TRUE);
    }
    /* XXX not really */
    ext_set("GL_EXT_separate_specular_color", GL_TRUE);
    ext_set("GL_EXT_secondary_color", GL_TRUE);

    return ctx;

  exit_error4:
    free_a(vb);
  exit_error3:
    tm_fini();
  exit_error2:
    ctx_fini();
  exit_error1:
    free(ctx);
  exit_error:
    return NULL;
}
Beispiel #8
0
/*
 * Start a file transfer, based on the contents of an ft_state structure.
 *
 * This function will fail if the file exists and the overwrite flag is not
 * set.
 *
 * Returns the local file pointer, or NULL if the transfer could not start.
 * If an error is detected, it will call popup_an_error() with an appropriate
 * message.
 */
FILE *
ft_go(ft_conf_t *p)
{
    FILE *f;
    varbuf_t r;
    unsigned flen;

    /* Adjust the DFT buffer size. */
    p->dft_buffersize = set_dft_buffersize(p->dft_buffersize);

    /* See if the local file can be overwritten. */
    if (p->receive_flag && !p->append_flag && !p->allow_overwrite) {
	f = fopen(p->local_filename, p->ascii_flag? "r": "rb");
	if (f != NULL) {
	    (void) fclose(f);
	    popup_an_error("Transfer: File exists");
	    return NULL;
	}
    }

    /* Open the local file. */
    f = fopen(p->local_filename, ft_local_fflag(p));
    if (f == NULL) {
	popup_an_errno(errno, "Local file '%s'", p->local_filename);
	return NULL;
    }

    /* Build the ind$file command */
    vb_init(&r);
    vb_appendf(&r, "IND\\e005BFILE %s %s %s",
	    p->receive_flag? "GET": "PUT",
	    p->host_filename,
	    (p->host_type != HT_TSO)? "(": "");
    if (p->ascii_flag) {
	vb_appends(&r, "ASCII");
    } else if (p->host_type == HT_CICS) {
	vb_appends(&r, "BINARY");
    }
    if (p->ascii_flag && p->cr_flag) {
	vb_appends(&r, " CRLF");
    } else if (p->host_type == HT_CICS) {
	vb_appends(&r, " NOCRLF");
    }
    if (p->append_flag && !p->receive_flag) {
	vb_appends(&r, " APPEND");
    }
    if (!p->receive_flag) {
	if (p->host_type == HT_TSO) {
	    if (p->recfm != DEFAULT_RECFM) {
		/* RECFM Entered, process */
		vb_appends(&r, " RECFM(");
		switch (p->recfm) {
		case RECFM_FIXED:
		    vb_appends(&r, "F");
		    break;
		case RECFM_VARIABLE:
		    vb_appends(&r, "V");
		    break;
		case RECFM_UNDEFINED:
		    vb_appends(&r, "U");
		    break;
		default:
		    break;
		};
		vb_appends(&r, ")");
		if (p->lrecl) {
		    vb_appendf(&r, " LRECL(%d)", p->lrecl);
		}
		if (p->blksize) {
		    vb_appendf(&r, " BLKSIZE(%d)", p->blksize);
		}
	    }
	    if (p->units != DEFAULT_UNITS) {
		/* Space Entered, processs it */
		vb_appendf(&r, " SPACE(%d", p->primary_space);
		if (p->secondary_space) {
		    vb_appendf(&r, ",%d", p->secondary_space);
		}
		vb_appends(&r, ")");
		switch (p->units) {
		case TRACKS:
		    vb_appends(&r, " TRACKS");
		    break;
		case CYLINDERS:
		    vb_appends(&r, " CYLINDERS");
		    break;
		case AVBLOCK:
		    vb_appendf(&r, " AVBLOCK(%d)", p->avblock);
		    break;
		default:
		    break;
		}
	    }
	} else if (p->host_type == HT_VM) {
	    if (p->recfm != DEFAULT_RECFM) {
		vb_appends(&r, " RECFM ");
		switch (p->recfm) {
		case RECFM_FIXED:
		    vb_appends(&r, "F");
		    break;
		case RECFM_VARIABLE:
		    vb_appends(&r, "V");
		    break;
		default:
		    break;
		};

		if (p->lrecl) {
		    vb_appendf(&r, " LRECL %d", p->lrecl);
		}
	    }
	}
    }
    vb_appends(&r, "\\n");

    /* Erase the line and enter the command. */
    flen = kybd_prime();
    if (!flen || flen < vb_len(&r) - 1) {
	vb_free(&r);
	if (f != NULL) {
	    fclose(f);
	    if (p->receive_flag && !p->append_flag) {
		unlink(p->local_filename);
	    }
	}
	popup_an_error("%s", get_message("ftUnable"));
	return NULL;
    }
    (void) emulate_input(vb_buf(&r), vb_len(&r), false);
    vb_free(&r);

    /* Now proceed with this context. */
    ftc = p;

    /* Finish common initialization. */
    fts.last_cr = false;
    fts.is_cut = false;
    fts.last_dbcs = false;
    fts.dbcs_state = FT_DBCS_NONE;

    ft_state = FT_AWAIT_ACK;
    idle_ft_start();

    return f;
}
Beispiel #9
0
/*!
  @brief   Get information about running processes.
  @ingroup system_misc
  @return  List of process entries.
  @retval  NULL if it failed.

  Each entry in the list is a hash containing the following entries:

    - \c USER -- user owning the process
    - \c PID -- process ID
    - \c PPID -- parent process ID
    - \c ENV -- explicit environment settings
    - \c PROG -- program being run
    - \c ARGS -- program arguments
*/
vlist *
v_procinfo(void)
{
#ifdef HAVE_POPEN
    char user[1024], *line, cmd[1024], linebuf[1024], *token;
    static vbuffer *env = NULL, *prog = NULL, *args = NULL;
    vlist *list = NULL;
    FILE *fp = NULL;
    int pid, ppid;
    vhash *data;

#ifdef HAVE_UID
    struct passwd *pw;
    int uid;
#endif

    /* Open pipe */
    if ((fp = popen(PS_CMD, "r")) == NULL)
        return NULL;

    /* Skip over header line */
    if (fgets(linebuf, 1024, fp) == NULL) {
        pclose(fp);
        return NULL;
    }

    list = vl_create();

    /* Read process info */
    while ((line = fgets(linebuf, 1024, fp)) != NULL) {
        /* Get the data */
#ifdef HAVE_UID
        sscanf(line, PS_FMT, &uid, &pid, &ppid, cmd);

        if ((pw = getpwuid(uid)) != NULL)
            strcpy(user, pw->pw_name);
        else
            strcpy(user, "nobody");
#else
        sscanf(line, PS_FMT, user, &pid, &ppid, cmd);
#endif

        /* Skip uninteresting processes */
        if (cmd[0] == '[')
            continue;

        /* Add process */
        data = vh_create();
        vl_ppush(list, data);

        vh_sstore(data, "USER", user);
        vh_istore(data, "PID",  pid);
        vh_istore(data, "PPID", ppid);

        /* Extract environment, program and arguments from command */
        vb_init(env);
        vb_init(prog);
        vb_init(args);

        token = strtok(cmd, " ");
        while (token != NULL) {
            if (vb_length(env) == 0 &&
                vb_length(prog) == 0 &&
                strchr(token, '=') != NULL)
                BUF_APPEND(env, token);
            else if (vb_length(prog) == 0)
                BUF_APPEND(prog, token);
            else
                BUF_APPEND(args, token);

            token = strtok(NULL, " ");
        }

        if (vb_length(env) > 0)
            vh_sstore(data, "ENV", vb_get(env));

        if (vb_length(prog) > 0)
            vh_sstore(data, "PROG", vb_get(prog));

        if (vb_length(args) > 0)
            vh_sstore(data, "ARGS", vb_get(args));
    }

    pclose(fp);
    return list;
#else
    v_unavailable("v_procinfo()");
    return NULL;
#endif
}