static void shift_down(void *elems, size_t elem_count, size_t i, size_t elem_size, int (*cmp)(const void *, const void *))
{
while(1) {
size_t l = ((i + 1) << 1) - 1;
size_t r = l + 1;
size_t greatest = i;
void *left_elem, *right_elem;
void *parent_elem = array_elem(elems, i, elem_size);
void *greatest_elem = parent_elem;
if(l < elem_count) {
left_elem = array_elem(elems, l, elem_size);
if(cmp(left_elem, parent_elem) > 0) {
greatest_elem = left_elem;
greatest = l;
}
}
if(r < elem_count) {
right_elem = array_elem(elems, r, elem_size);
if(cmp(right_elem, greatest_elem) > 0) {
greatest_elem = right_elem;
greatest = r;
}
}
if(i == greatest) return;
swap(parent_elem, greatest_elem, elem_size);
i = greatest;
}
}
/**
* set_input_format
* Sets input format ( PAL, NTSC, SECAM, etc ... )
*/
static int set_input_format(struct video_dev *viddev, unsigned newformat)
{
int input_format[] = { NORM_PAL_NEW, NORM_NTSC_NEW, NORM_SECAM_NEW, NORM_DEFAULT_NEW};
int format;
if (newformat >= array_elem(input_format)) {
MOTION_LOG(WRN, TYPE_VIDEO, NO_ERRNO, "%s: Input format %d out of range (0-2)",
newformat);
return -1;
}
format = input_format[newformat];
if (ioctl(viddev->fd_bktr, BT848SFMT, &format) < 0) {
MOTION_LOG(WRN, TYPE_VIDEO, SHOW_ERRNO, "%s: BT848SFMT, Couldn't set the input format, "
"try again with default");
format = NORM_DEFAULT_NEW;
newformat = 3;
if (ioctl(viddev->fd_bktr, BT848SFMT, &format) < 0) {
MOTION_LOG(ERR, TYPE_VIDEO, SHOW_ERRNO, "%s: BT848SFMT, Couldn't set the input format "
"either default");
return -1;
}
}
MOTION_LOG(NTC, TYPE_VIDEO, NO_ERRNO, "%s: to %d", newformat);
return newformat;
}
static int bktr_set_input_device(struct video_dev *viddev, unsigned input)
{
int actport;
int portdata[] = { METEOR_INPUT_DEV0, METEOR_INPUT_DEV1,
METEOR_INPUT_DEV2, METEOR_INPUT_DEV3,
METEOR_INPUT_DEV_SVIDEO };
if (input >= array_elem(portdata)) {
MOTION_LOG(ERR, TYPE_VIDEO, NO_ERRNO, "%s: Device Input %d out of range (0-4)",
input);
return -1;
}
actport = portdata[ input ];
if (ioctl(viddev->fd_device, METEORSINPUT, &actport) < 0) {
if (input != BKTR_IN_COMPOSITE) {
MOTION_LOG(ERR, TYPE_VIDEO, SHOW_ERRNO, "%s: METEORSINPUT %d invalid -"
"Trying composite %d", input, BKTR_IN_COMPOSITE);
input = BKTR_IN_COMPOSITE;
actport = portdata[ input ];
if (ioctl(viddev->fd_device, METEORSINPUT, &actport) < 0) {
MOTION_LOG(ERR, TYPE_VIDEO, SHOW_ERRNO, "%s: METEORSINPUT %d init", input);
return -1;
}
} else {
MOTION_LOG(ERR, TYPE_VIDEO, SHOW_ERRNO, "%s: METEORSINPUT %d init",
input);
return -1;
}
}
MOTION_LOG(NTC, TYPE_VIDEO, NO_ERRNO, "%s: to [%d]", input);
return input;
}
static int set_input(struct video_dev *viddev, unsigned short input)
{
int actport;
int portdata[] = { METEOR_INPUT_DEV0, METEOR_INPUT_DEV1,
METEOR_INPUT_DEV2, METEOR_INPUT_DEV3,
METEOR_INPUT_DEV_SVIDEO};
if (input >= array_elem(portdata)) {
motion_log(LOG_INFO, 0, "%s: Channel Port %d out of range (0-4)", __FUNCTION__, input);
return -1;
}
actport = portdata[input];
if (ioctl(viddev->fd_bktr, METEORSINPUT, &actport) < 0) {
if (input != IN_DEFAULT) {
motion_log(LOG_INFO, 1, "%s: METEORSINPUT %d invalid - Trying default %d",
__FUNCTION__, input, IN_DEFAULT);
input = IN_DEFAULT;
actport = portdata[input];
if (ioctl(viddev->fd_bktr, METEORSINPUT, &actport) < 0) {
motion_log(LOG_ERR, 1, "%s: METEORSINPUT %d init", __FUNCTION__, input);
return -1;
}
} else {
motion_log(LOG_ERR, 1, "%s: METEORSINPUT %d init", __FUNCTION__, input);
return -1;
}
}
if (debug_level >= CAMERA_VIDEO)
motion_log(-1, 0, "%s: to [%d]", __FUNCTION__, input);
return input;
}
static int set_input_format(struct video_dev *viddev, unsigned short newformat)
{
int input_format[] = { NORM_PAL_NEW, NORM_NTSC_NEW, NORM_SECAM_NEW, NORM_DEFAULT_NEW};
int format;
if (newformat >= array_elem( input_format )) {
motion_log(LOG_WARNING, 0, "%s: Input format %d out of range (0-2)", __FUNCTION__, newformat);
return -1;
}
format = input_format[newformat];
if (ioctl( viddev->fd_bktr, BT848SFMT, &format) < 0) {
motion_log(LOG_ERR, 1, "%s: BT848SFMT, Couldn't set the input format , try again with default",
__FUNCTION__);
format = NORM_DEFAULT_NEW;
newformat = 3;
if (ioctl(viddev->fd_bktr, BT848SFMT, &format) < 0) {
motion_log(LOG_ERR, 1, "%s: BT848SFMT, Couldn't set the input format either default",
__FUNCTION__);
return -1;
}
}
if (debug_level >= CAMERA_VIDEO)
motion_log(-1, 0, "%s: to %d", __FUNCTION__, newformat);
return newformat;
}
void opt_destroy(void) {
size_t i;
for (i = 0 ; i < array_elem(global_pref) ; i++) {
if (global_pref[i].dynamic)
free(global_pref[i].val.s);
}
}
static int event_find(const char *name) {
struct event_info *info;
u_int32_t offset;
info = bsearch(name, events_info, array_elem(events_info),
sizeof(struct event_info), event_compare);
if (info == NULL)
return (-1);
offset = (long) info - (long) &events_info[0];
return (offset / sizeof(struct event_info));
}
int wopt_find(const char *name) {
struct window_var *wvar;
uint32_t offset;
wvar = bsearch(name, window_var, array_elem(window_var),
sizeof(struct window_var), wopt_compare);
if (wvar == NULL)
return (-1);
offset = (long) wvar - (long) &window_var[0];
return (offset / sizeof(struct window_var));
}
int opt_find(const char *name) {
struct global_pref *gvar;
uint32_t offset;
gvar = bsearch(name, global_pref, array_elem(global_pref),
sizeof(struct global_pref), opt_compare);
if (gvar == NULL)
return (-1);
offset = (long) gvar - (long) &global_pref[0];
return (offset / sizeof(struct global_pref));
}
static int
SPF_i_match_ip6(SPF_server_t *spf_server,
SPF_request_t *spf_request,
SPF_mech_t *mech,
struct in6_addr ipv6 )
{
char src_ip6_buf[ INET6_ADDRSTRLEN ];
char dst_ip6_buf[ INET6_ADDRSTRLEN ];
struct in6_addr src_ipv6;
int cidr, cidr_save, mask;
int i;
int match;
if ( spf_request->client_ver != AF_INET6 )
return FALSE;
src_ipv6 = spf_request->ipv6;
cidr = SPF_i_mech_cidr(spf_request, mech);
if ( cidr == 0 )
cidr = 128;
cidr_save = cidr;
match = TRUE;
for( i = 0; i < array_elem( ipv6.s6_addr ) && match; i++ )
{
if ( cidr > 8 )
mask = 0xff;
else if ( cidr > 0 )
mask = (0xff << (8 - cidr)) & 0xff;
else
break;
cidr -= 8;
match = (src_ipv6.s6_addr[i] & mask) == (ipv6.s6_addr[i] & mask);
}
if (spf_server->debug) {
INET_NTOP(AF_INET6, &src_ipv6.s6_addr,
src_ip6_buf, sizeof(src_ip6_buf));
INET_NTOP(AF_INET6, &ipv6.s6_addr,
dst_ip6_buf, sizeof(dst_ip6_buf));
SPF_debugf( "ip_match: %s == %s (/%d): %d",
src_ip6_buf, dst_ip6_buf, cidr_save, match );
}
return match;
}
void text_renderer_destroy(text_renderer_p renderer) {
texture_destroy(renderer->texture);
for(size_t i = 0; i < renderer->lines->length; i++)
array_destroy( array_elem(renderer->lines, text_renderer_line_t, i).cells );
array_destroy(renderer->lines);
for(hash_elem_t e = hash_start(renderer->fonts); e != NULL; e = hash_next(renderer->fonts, e))
text_renderer_font_destroy(renderer, hash_key(e));
hash_destroy(renderer->fonts);
FT_Error error = FT_Done_FreeType(renderer->freetype);
if (error)
printf("FT_Done_FreeType error\n");
}
void opt_write(FILE *fp) {
size_t i;
for (i = 0 ; i < array_elem(global_pref) ; i++) {
switch (global_pref[i].type) {
case OPT_BOOL:
fprintf(fp, "set %s %s\n", global_pref[i].name,
(global_pref[i].val.b ? "TRUE" : "FALSE"));
break;
case OPT_STR:
if (global_pref[i].val.s != NULL &&
global_pref[i].val.s[0] != '\0')
{
fprintf(fp, "set %s %s\n", global_pref[i].name,
global_pref[i].val.s);
}
break;
case OPT_INT:
fprintf(fp, "set %s %d\n", global_pref[i].name,
global_pref[i].val.i);
break;
case OPT_CHAR:
if (isprint(global_pref[i].val.c)) {
fprintf(fp, "set %s %c\n", global_pref[i].name,
global_pref[i].val.c);
} else {
fprintf(fp, "set %s 0x%x\n", global_pref[i].name,
global_pref[i].val.c);
}
break;
case OPT_COLOR: {
char buf[128];
color_get_str(global_pref[i].val.i, buf, sizeof(buf));
fprintf(fp, "set %s %s\n", global_pref[i].name, buf);
break;
}
}
}
}
int opt_set_color(uint32_t opt, char *args) {
attr_t attr = 0;
if (*args != '%') {
if (color_parse_code(args, &attr) == -1)
return (-1);
} else {
char buf[32];
chtype ch[4];
snprintf(buf, sizeof(buf), "%s ", args);
if (plaintext_to_cstr(ch, array_elem(ch), buf, NULL) != 1)
return (-1);
attr = ch[0] & A_ATTRIBUTES;
}
global_pref[opt].val.i = attr;
if (global_pref[opt].updated != NULL)
global_pref[opt].updated();
return (0);
}
/**
* set_input
* Sets the input to capture images , could be tuner (METEOR_INPUT_DEV1)
* or any of others input :
* RCA/COMPOSITE1 (METEOR_INPUT_DEV0)
* COMPOSITE2/S-VIDEO (METEOR_INPUT_DEV2)
* S-VIDEO (METEOR_INPUT_DEV3)
* VBI ?! (METEOR_INPUT_DEV_SVIDEO)
*/
static int set_input(struct video_dev *viddev, unsigned input)
{
int actport;
int portdata[] = { METEOR_INPUT_DEV0, METEOR_INPUT_DEV1,
METEOR_INPUT_DEV2, METEOR_INPUT_DEV3,
METEOR_INPUT_DEV_SVIDEO };
if (input >= array_elem(portdata)) {
MOTION_LOG(ERR, TYPE_VIDEO, NO_ERRNO, "%s: Channel Port %d out of range (0-4)",
input);
return -1;
}
actport = portdata[ input ];
if (ioctl(viddev->fd_bktr, METEORSINPUT, &actport) < 0) {
if (input != IN_DEFAULT) {
MOTION_LOG(ERR, TYPE_VIDEO, SHOW_ERRNO, "%s: METEORSINPUT %d invalid -"
"Trying default %d", input, IN_DEFAULT);
input = IN_DEFAULT;
actport = portdata[ input ];
if (ioctl(viddev->fd_bktr, METEORSINPUT, &actport) < 0) {
MOTION_LOG(ERR, TYPE_VIDEO, SHOW_ERRNO, "%s: METEORSINPUT %d init",
input);
return -1;
}
} else {
MOTION_LOG(ERR, TYPE_VIDEO, SHOW_ERRNO, "%s: METEORSINPUT %d init",
input);
return -1;
}
}
MOTION_LOG(NTC, TYPE_VIDEO, NO_ERRNO, "%s: to [%d]", input);
return input;
}
size_t text_renderer_render(text_renderer_p renderer, int32_t font_handle, char* text, size_t x, size_t y, float* buffer_ptr, size_t buffer_size) {
text_renderer_font_p font = hash_get_ptr(renderer->fonts, font_handle);
if (!font)
return 0;
// The current position is the baseline of the text so start one line down
// from the position. Otherwise we would render above it.
size_t pos_x = x, pos_y = y + (font->face->size->metrics.height / 64);
float* p = buffer_ptr;
FT_UInt glyph_index = 0, prev_glyph_index = 0;
glBindTexture(GL_TEXTURE_RECTANGLE, renderer->texture);
// Lookup the size of our texture (needed by find_free_cell_or_revoke_unused_cell() for some checks)
GLint texture_width = 0, texture_height = 0;
glGetTexLevelParameteriv(GL_TEXTURE_RECTANGLE, 0, GL_TEXTURE_WIDTH, &texture_width);
glGetTexLevelParameteriv(GL_TEXTURE_RECTANGLE, 0, GL_TEXTURE_HEIGHT, &texture_height);
GLint unpack_alignment = 0;
glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpack_alignment);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
for(utf8_iterator_t it = utf8_first(text); it.code_point != 0; it = utf8_next(it)) {
// Handle line break.
if (it.code_point == '\n') {
pos_y += font->face->size->metrics.height / 64;
pos_x = x;
// Don't do kerning at the next character after the line break.
prev_glyph_index = 0;
continue;
}
// Look if this glyph is present in the texture. If so this font has a cell reference
// for this code point.
text_renderer_cell_ref_p cell_ref = hash_get_ptr(font->cell_refs, it.code_point);
// Glyph not rendered yet, try to render it
if (!cell_ref) {
glyph_index = FT_Get_Char_Index(font->face, it.code_point);
if (glyph_index == 0)
goto render_error_glyph;
FT_Error error = FT_Load_Glyph(font->face, glyph_index, FT_LOAD_RENDER);
if (error)
goto render_error_glyph;
// Look for a free cell to store the rendered glyph
uint32_t gw = font->face->glyph->bitmap.width, gh = font->face->glyph->bitmap.rows;
size_t line_idx = 0, cell_idx = 0;
text_renderer_cell_p free_cell = find_free_cell_or_revoke_unused_cell(renderer, font, gw, gh, texture_width, texture_height, &line_idx, &cell_idx);
if (free_cell == NULL)
goto render_error_glyph;
free_cell->glyph_index = glyph_index;
free_cell->hori_bearing_x = font->face->glyph->metrics.horiBearingX / 64;
free_cell->hori_bearing_y = font->face->glyph->metrics.horiBearingY / 64;
free_cell->hori_advance = font->face->glyph->metrics.horiAdvance / 64;
/*
printf("%c: %2ux%2u %2u bytes, pitch %u, x: %u, y: %u hori_bearing: %2u/%2u, adv: %2u\n",
it.code_point, gw, gh, gw*gh, font->face->glyph->bitmap.pitch,
free_cell->x, free_cell->y, free_cell->hori_bearing_x, free_cell->hori_bearing_y, free_cell->hori_advance);
*/
glPixelStorei(GL_UNPACK_ROW_LENGTH, font->face->glyph->bitmap.pitch);
glTexSubImage2D(GL_TEXTURE_RECTANGLE, 0, free_cell->x, free_cell->y, gw, gh, GL_RED, GL_UNSIGNED_BYTE, font->face->glyph->bitmap.buffer);
cell_ref = hash_put_ptr(font->cell_refs, it.code_point);
cell_ref->line_idx = line_idx;
cell_ref->cell_idx = cell_idx;
}
// Glyph rendered successfully, do kerning and generate vertices for it
text_renderer_line_t line = array_elem(renderer->lines, text_renderer_line_t, cell_ref->line_idx);
text_renderer_cell_t cell = array_elem(line.cells, text_renderer_cell_t, cell_ref->cell_idx);
if (cell.glyph_index && prev_glyph_index) {
FT_Vector delta;
FT_Get_Kerning(font->face, prev_glyph_index, glyph_index, FT_KERNING_DEFAULT, &delta);
pos_x += delta.x / 64;
}
// We have the texture coordinates of the glyph, generate the vertex buffer
if ( (p + 6*4 - buffer_ptr) * sizeof(float) < buffer_size ) {
float w = cell.width, h = line.height;
float cx = pos_x + cell.hori_bearing_x;
float cy = pos_y - cell.hori_bearing_y;
float tl_x = cx + 0, tl_y = cy + 0, tl_u = cell.x, tl_v = cell.y;
float tr_x = cx + w, tr_y = cy + 0, tr_u = cell.x + w, tr_v = cell.y;
float bl_x = cx + 0, bl_y = cy + h, bl_u = cell.x, bl_v = cell.y + h;
float br_x = cx + w, br_y = cy + h, br_u = cell.x + w, br_v = cell.y + h;
*(p++) = tl_x; *(p++) = tl_y; *(p++) = tl_u; *(p++) = tl_v;
*(p++) = tr_x; *(p++) = tr_y; *(p++) = tr_u; *(p++) = tr_v;
*(p++) = bl_x; *(p++) = bl_y; *(p++) = bl_u; *(p++) = bl_v;
*(p++) = tr_x; *(p++) = tr_y; *(p++) = tr_u; *(p++) = tr_v;
*(p++) = br_x; *(p++) = br_y; *(p++) = br_u; *(p++) = br_v;
*(p++) = bl_x; *(p++) = bl_y; *(p++) = bl_u; *(p++) = bl_v;
pos_x += cell.hori_advance;
}
prev_glyph_index = glyph_index;
continue;
render_error_glyph:
// For now just output nothing when we fail to render a glyph.
// TODO: Figure out how to render a kind of error glyph.
prev_glyph_index = glyph_index;
continue;
}
glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glBindTexture(GL_TEXTURE_RECTANGLE, 0);
return (p - buffer_ptr) * sizeof(float);
}
/**
* This could better collect errors, like the compiler does.
* This requires that *bufp be either malloced to *buflenp, or NULL
* This may realloc *bufp.
*/
SPF_errcode_t
SPF_record_expand_data(SPF_server_t *spf_server,
SPF_request_t *spf_request,
SPF_response_t *spf_response,
SPF_data_t *data, size_t data_len,
char **bufp, size_t *buflenp)
{
SPF_data_t *d, *data_end;
size_t len;
const char *p_err; // XXX Check this value, when returned.
char *p, *p_end;
const char *p_read;
const char *p_read_end;
char *p_write;
char *p2, *p2_end;
const char *var;
char *munged_var = NULL;
char *url_var = NULL;
/* Pretty-printing buffers. */
char ip4_buf[ INET_ADDRSTRLEN ];
char ip6_buf[ INET6_ADDRSTRLEN ];
/* Hex buffer for ipv6 (size in nibbles) */
char ip6_rbuf[ sizeof( struct in6_addr ) * 4 + 1 ];
char time_buf[ sizeof( "4294967296" ) ]; /* 2^32 seconds max */
int num_found;
int i;
size_t buflen;
int compute_length;
SPF_errcode_t err;
/*
* make sure we were passed valid data to work with
*/
SPF_ASSERT_NOTNULL(spf_server);
SPF_ASSERT_NOTNULL(data);
SPF_ASSERT_NOTNULL(bufp);
SPF_ASSERT_NOTNULL(buflenp);
buflen = 1; /* For the terminating '\0' */
compute_length = 1;
p = NULL;
p_end = NULL;
/* data_end = SPF_mech_end_data( mech ); */ /* doesn't work for mods */
data_end = (SPF_data_t *)((char *)data + data_len);
top:
#ifdef DEBUG
fprintf(stderr, "Pass start compute_length=%d\n", compute_length);
#endif
/*
* expand the data
*/
for (d = data; d < data_end; d = SPF_data_next(d)) {
#ifdef DEBUG
fprintf(stderr, " Item type=%d at %p\n", d->dc.parm_type, d);
#endif
if (d->dc.parm_type == PARM_CIDR)
continue;
if (d->ds.parm_type == PARM_STRING) {
if (compute_length) {
buflen += d->ds.len;
continue;
}
/* This should NEVER happen now. */
if (p_end - (p + d->ds.len) <= 0)
SPF_error("Failed to allocate enough memory "
"to expand string.");
memcpy(p, SPF_data_str(d), d->ds.len);
p += d->ds.len;
continue;
}
/* Otherwise, it's a variable. */
var = NULL;
switch (d->dv.parm_type) {
case PARM_LP_FROM: /* local-part of envelope-sender */
var = spf_request->env_from_lp;
break;
case PARM_ENV_FROM: /* envelope-sender */
var = spf_request->env_from;
break;
case PARM_DP_FROM: /* envelope-domain */
var = spf_request->env_from_dp;
break;
case PARM_CUR_DOM: /* current-domain */
var = spf_request->cur_dom;
break;
case PARM_CLIENT_IP: /* SMTP client IP */
if (compute_length) {
len = sizeof(ip6_buf);
if (d->dv.url_encode)
len *= 3;
buflen += len;
continue;
}
if (spf_request->client_ver == AF_INET) {
p_err = inet_ntop(AF_INET, &spf_request->ipv4,
ip4_buf, sizeof(ip4_buf));
var = ip4_buf;
}
else if (spf_request->client_ver == AF_INET6) {
p2 = ip6_rbuf;
p2_end = p2 + sizeof(ip6_rbuf);
for (i = 0; i < array_elem(spf_request->ipv6.s6_addr); i++) {
p2 += snprintf(p2, p2_end - p2, "%.1x.%.1x.",
spf_request->ipv6.s6_addr[i] >> 4,
spf_request->ipv6.s6_addr[i] & 0xf);
}
/* squash the final '.' */
ip6_rbuf[sizeof(struct in6_addr) * 4 - 1] = '\0';
var = ip6_rbuf;
}
break;
case PARM_CLIENT_IP_P: /* SMTP client IP (pretty) */
if (compute_length) {
len = sizeof(ip6_buf);
if (d->dv.url_encode)
len *= 3;
buflen += len;
continue;
}
if (spf_request->client_ver == AF_INET) {
p_err = inet_ntop(AF_INET, &spf_request->ipv4,
ip4_buf, sizeof(ip4_buf));
var = ip4_buf;
}
else if (spf_request->client_ver == AF_INET6) {
p_err = inet_ntop(AF_INET6, &spf_request->ipv6,
ip6_buf, sizeof(ip6_buf));
var = ip6_buf;
}
break;
case PARM_TIME: /* time in UTC epoch secs */
if (compute_length) {
len = sizeof(time_buf);
/* This never gets bigger using URL encoding. */
buflen += len;
continue;
}
snprintf(time_buf, sizeof(time_buf), "%ld",
(long)time(NULL));
var = time_buf;
break;
case PARM_CLIENT_DOM: /* SMTP client domain name */
var = SPF_request_get_client_dom(spf_request);
if (! var)
return SPF_E_NO_MEMORY;
break;
case PARM_CLIENT_VER: /* IP ver str - in-addr/ip6 */
if (spf_request->client_ver == AF_INET)
var = client_ver_ipv4;
else if (spf_request->client_ver == AF_INET6)
var = client_ver_ipv6;
break;
case PARM_HELO_DOM: /* HELO/EHLO domain */
var = spf_request->helo_dom;
break;
case PARM_REC_DOM: /* receiving domain */
var = SPF_request_get_rec_dom(spf_request);
break;
default:
#ifdef DEBUG
fprintf(stderr, "Invalid variable %d\n", d->dv.parm_type);
#endif
return SPF_E_INVALID_VAR;
break;
}
if (var == NULL)
return SPF_E_UNINIT_VAR;
len = strlen(var);
if (compute_length) {
if (d->dv.url_encode)
len *= 3;
buflen += len;
continue;
}
/* Now we put 'var' through the munging procedure. */
munged_var = (char *)malloc(len + 1);
if (munged_var == NULL)
return SPF_E_NO_MEMORY;
memset(munged_var, 0, len + 1);
p_read_end = var + len;
p_write = munged_var;
/* reverse */
/* The following code confuses both me and Coverity. Shevek. */
if (d->dv.rev) {
p_read = p_read_end - 1;
while ( p_read >= var ) {
if ( SPF_delim_valid(d, *p_read) ) {
/* Subtract 1 because p_read points to delim, and
* p_read_end points to the following delim. */
len = p_read_end - p_read - 1;
memcpy( p_write, p_read + 1, len );
p_write += len;
*p_write++ = '.';
p_read_end = p_read;
}
p_read--;
}
/* Now p_read_end should point one before the start of the
* string. p_read_end might also point there if the string
* starts with a delimiter. */
if (p_read_end >= p_read) {
len = p_read_end - p_read - 1;
memcpy( p_write, p_read + 1, len );
p_write += len;
*p_write++ = '.';
}
/* p_write always points to the 'next' character. */
p_write--;
*p_write = '\0';
}
else {
p_read = var;
while (p_read < p_read_end) {
if (SPF_delim_valid(d, *p_read))
*p_write++ = '.';
else
*p_write++ = *p_read;
p_read++;
}
*p_write = '\0';
}
/* Now munged_var is a copy of var, possibly reversed, and
* thus len == strlen(munged_var). However, we continue to
* manipulate the underlying munged_var since var is const. */
/* truncate, from the right hand side. */
if (d->dv.num_rhs > 0) {
p_read_end = munged_var + len; /* const, at '\0' */
p_write = munged_var + len - 1;
num_found = 0;
while (p_write > munged_var) {
if (*p_write == '.')
num_found++;
if (num_found == d->dv.num_rhs)
break;
p_write--;
}
p_write++; /* Move to just after the '.' */
/* This moves the '\0' as well. */
len = p_read_end - p_write;
memmove(munged_var, p_write, len + 1);
}
var = munged_var;
/* Now, we have 'var', of length 'len' */
/* URL encode */
if (d->dv.url_encode) {
url_var = malloc(len * 3 + 1);
if (url_var == NULL) {
if (munged_var)
free(munged_var);
return SPF_E_NO_MEMORY;
}
p_read = var;
p_write = url_var;
/* escape non-uric characters (rfc2396) */
while ( *p_read != '\0' )
{
if ( isalnum( (unsigned char)( *p_read ) ) )
*p_write++ = *p_read++;
else
{
switch( *p_read )
{
case '-':
case '_':
case '.':
case '!':
case '~':
case '*':
case '\'':
case '(':
case ')':
*p_write++ = *p_read++;
break;
default:
/* No point doing snprintf with a const '4'
* because we know we're going to get 4
* characters anyway. */
sprintf( p_write, "%%%02x", *p_read );
p_write += 3;
p_read++;
break;
}
}
}
*p_write = '\0';
var = url_var;
len = p_write - url_var; /* Not actually used. */
}
/* finish up */
len = snprintf(p, p_end - p, "%s", var);
p += len;
if (p_end - p <= 0) {
if (munged_var)
free(munged_var);
if (url_var)
free(url_var);
return SPF_E_INTERNAL_ERROR;
}
if (munged_var)
free(munged_var);
munged_var = NULL;
if (url_var)
free(url_var);
url_var = NULL;
}
static void genvalue(Sfio_t *out, Shclass_t *sp, int indent, Namval_t *npar)
{
Shfield_t *fp = sp->fields;
Namval_t *np, **nodes= (Namval_t**)(sp+1);
register int i,isarray;
if(out)
{
sfwrite(out,"(\n",2);
indent++;
}
for(i=0; i < sp->nelem; i++,fp++)
{
#if 0
/* handle recursive case */
#endif
if(!(np=nodes[i]) && out)
np = sh_newnode(fp,npar);
if(np)
{
isarray=0;
if(nv_isattr(np,NV_ARRAY))
{
isarray=1;
if(array_elem(nv_arrayptr(np))==0)
isarray=2;
else
nv_putsub(np,(char*)0,ARRAY_SCAN);
}
sfnputc(out,'\t',indent);
sfputr(out,fp->name,(isarray==2?'\n':'='));
if(isarray)
{
if(isarray==2)
continue;
sfwrite(out,"(\n",2);
sfnputc(out,'\t',++indent);
}
while(1)
{
char *fmtq;
if(isarray)
{
sfprintf(out,"[%s]",sh_fmtq(nv_getsub(np)));
sfputc(out,'=');
}
if(!(fmtq=nv_getval(np)) || !(fmtq=sh_fmtq(fmtq)))
fmtq = "";
sfputr(out,fmtq,'\n');
if(!nv_nextsub(np))
break;
sfnputc(out,'\t',indent);
}
if(isarray)
{
sfnputc(out,'\t',--indent);
sfwrite(out,")\n",2);
}
}
}
if(out)
{
if(indent>1)
sfnputc(out,'\t',indent-1);
sfputc(out,')');
}
}
void opt_print(void) {
size_t i;
for (i = 0 ; i < array_elem(global_pref) ; i++)
opt_print_var(i, "is set to");
}
void wopt_print(struct imwindow *imwindow) {
size_t i;
for (i = 0 ; i < array_elem(window_var) ; i++)
wopt_print_var(imwindow, i, "is set to");
}
