/*
* Read symbol specified by name.
* Name: group/name | group/name@mapset
* (later add syntax to prefer symbol from GISBASE)
* S_read() searches first in mapsets (standard GRASS search) and
* then in GISBASE/etc/symbol/
*/
SYMBOL *S_read(const char *sname)
{
int i, j, k, l;
FILE *fp;
char group[500], name[500], buf[2001];
const char *ms;
char *c;
double x, y, x2, y2, rad, ang1, ang2;
int r, g, b;
double fr, fg, fb;
int ret;
char clock;
SYMBOL *symb;
int current; /* current part_type */
SYMBPART *part; /* current part */
SYMBCHAIN *chain; /* current chain */
SYMBEL *elem; /* current element */
G_debug(3, "S_read(): sname = %s", sname);
/* Find file */
/* Get group and name */
strcpy(group, sname);
c = strchr(group, '/');
if (c == NULL) {
G_warning(_("Incorrect symbol name: '%s' (should be: group/name or group/name@mapset)"),
sname);
return NULL;
}
c[0] = '\0';
c++;
strcpy(name, c);
G_debug(3, " group: '%s' name: '%s'", group, name);
/* Search in mapsets */
sprintf(buf, "symbol/%s", group);
ms = G_find_file(buf, name, NULL);
if (ms != NULL) { /* Found in mapsets */
fp = G_fopen_old(buf, name, ms);
}
else { /* Search in GISBASE */
sprintf(buf, "%s/etc/symbol/%s", G_gisbase(), sname);
fp = fopen(buf, "r");
}
if (fp == NULL) {
G_warning(_("Cannot find/open symbol: '%s'"), sname);
return NULL;
}
/* create new symbol */
symb = new_symbol();
current = OBJ_NONE; /* no part */
/* read file */
while (G_getl2(buf, 2000, fp) != 0) {
G_chop(buf);
G_debug(3, " BUF: [%s]", buf);
/* skip empty and comment lines */
if ((buf[0] == '#') || (buf[0] == '\0'))
continue;
get_key_data(buf);
if (strcmp(key, "VERSION") == 0) {
if (strcmp(data, "1.0") != 0) {
sprintf(buf, "Wrong symbol version: '%s'", data);
return (err(fp, symb, buf));
}
}
else if (strcmp(key, "BOX") == 0) {
if (sscanf(data, "%lf %lf %lf %lf", &x, &y, &x2, &y2) != 4) {
sprintf(buf, "Incorrect box definition: '%s'", data);
return (err(fp, symb, buf));
}
symb->xscale = 1 / (x2 - x);
symb->yscale = 1 / (y2 - y);
if (x2 - x > y2 - y) {
symb->scale = symb->xscale;
}
else {
symb->scale = symb->yscale;
}
}
else if (strcmp(key, "STRING") == 0) {
G_debug(4, " STRING >");
current = OBJ_STRING;
part = new_part(S_STRING);
add_part(symb, part);
chain = new_chain();
add_chain(part, chain);
}
else if (strcmp(key, "POLYGON") == 0) {
G_debug(4, " POLYGON >");
current = OBJ_POLYGON;
part = new_part(S_POLYGON);
add_part(symb, part);
}
else if (strcmp(key, "RING") == 0) {
G_debug(4, " RING >");
current = OBJ_RING;
chain = new_chain();
add_chain(part, chain);
}
else if (strcmp(key, "LINE") == 0) {
G_debug(4, " LINE >");
elem = new_line();
add_element(chain, elem);
read_coor(fp, elem);
}
else if (strcmp(key, "ARC") == 0) {
G_debug(4, " ARC");
ret =
sscanf(data, "%lf %lf %lf %lf %lf %c", &x, &y, &rad, &ang1,
&ang2, &clock);
if (ret < 5) {
sprintf(buf, "Incorrect arc definition: '%s'", buf);
return (err(fp, symb, buf));
}
if (ret == 6 && (clock == 'c' || clock == 'C'))
i = 1;
else
i = 0;
elem = new_arc(x, y, rad, ang1, ang2, i);
add_element(chain, elem);
}
else if (strcmp(key, "END") == 0) {
switch (current) {
case OBJ_STRING:
G_debug(4, " STRING END");
current = OBJ_NONE;
break;
case OBJ_POLYGON:
G_debug(4, " POLYGON END");
current = OBJ_NONE;
break;
case OBJ_RING:
G_debug(4, " RING END");
current = OBJ_POLYGON;
break;
}
}
else if (strcmp(key, "COLOR") == 0) {
if (G_strcasecmp(data, "NONE") == 0) {
part->color.color = S_COL_NONE;
}
else if (sscanf(data, "%d %d %d", &r, &g, &b) == 3) {
if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255)
G_warning(_("Incorrect symbol color: '%s', using default."),
buf);
else {
fr = r / 255.0;
fg = g / 255.0;
fb = b / 255.0;
part->color.color = S_COL_DEFINED;
part->color.r = r;
part->color.g = g;
part->color.b = b;
part->color.fr = fr;
part->color.fg = fg;
part->color.fb = fb;
G_debug(4, " color [%d %d %d] = [%.3f %.3f %.3f]", r, g,
b, fr, fg, fb);
}
}
else {
G_warning(_("Incorrect symbol color: '%s', using default."),
buf);
}
}
else if (strcmp(key, "FCOLOR") == 0) {
if (G_strcasecmp(data, "NONE") == 0) {
part->fcolor.color = S_COL_NONE;
}
else if (sscanf(data, "%d %d %d", &r, &g, &b) == 3) {
if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255)
G_warning(_("Incorrect symbol color: '%s', using default."),
buf);
else {
fr = r / 255.0;
fg = g / 255.0;
fb = b / 255.0;
part->fcolor.color = S_COL_DEFINED;
part->fcolor.r = r;
part->fcolor.g = g;
part->fcolor.b = b;
part->fcolor.fr = fr;
part->fcolor.fg = fg;
part->fcolor.fb = fb;
G_debug(4, " color [%d %d %d] = [%.3f %.3f %.3f]", r, g,
b, fr, fg, fb);
}
}
else {
G_warning(_("Incorrect symbol color: '%s', using default."),
buf);
}
}
else {
sprintf(buf, "Unknown keyword in symbol: '%s'", buf);
return (err(fp, symb, buf));
break;
}
}
/* Debug output */
G_debug(3, "Number of parts: %d", symb->count);
for (i = 0; i < symb->count; i++) {
part = symb->part[i];
G_debug(4, " Part %d: type: %d number of chains: %d", i, part->type,
part->count);
G_debug(4, " color: %d: fcolor: %d", part->color.color,
part->fcolor.color);
for (j = 0; j < part->count; j++) {
chain = part->chain[j];
G_debug(4, " Chain %d: number of elements: %d", j,
chain->count);
for (k = 0; k < chain->count; k++) {
elem = chain->elem[k];
G_debug(4, " Element %d: type: %d", k, elem->type);
if (elem->type == S_LINE) {
G_debug(4, " Number of points %d",
elem->coor.line.count);
for (l = 0; l < elem->coor.line.count; l++) {
G_debug(4, " x, y: %f %f",
elem->coor.line.x[l], elem->coor.line.y[l]);
}
}
else {
G_debug(4, " arc r = %f", elem->coor.arc.r);
}
}
}
}
fclose(fp);
return symb;
}
struct compile_error expr_parse(struct input ci, struct expr_environ *env,
struct parse_options opts, struct objcode **ocode)
{
struct compile_error ret;
struct chain locals = new_chain();
struct proto_obj outp;
char *end_ptr;
int error = -E_OK, prev_stat=NADA, input_counter = 0;
ret = init_ce();
*ocode = NULL;
end_ptr = ""; /*force an input read ("" != NULL) */
//error = load_expr(&outp, expr);
error = po_init(&outp, opts.n_args, opts.n_rets);
while (error == -E_OK && end_ptr != NULL) {
char *startptr = end_ptr;
data_t tmp_data;
int tmp_int;
char *ident = NULL;
if (eatspace(startptr, &end_ptr)) {
/* do nothing */
} else if (*startptr == TERM) {
startptr = end_ptr = get_input(ci);
} else if (prev_stat == NADA &&
atodata_load(startptr, &end_ptr, &tmp_data)){
error = inject_data(&outp, tmp_data);
prev_stat = NADA;
} else if (prev_stat == ARG || prev_stat == NCLEAR) {
if (atoint_load(startptr, &end_ptr, &tmp_int)) {
if (prev_stat == ARG)
error = inject_arg(&outp, tmp_int);
else
error = inject_nclear(&outp, tmp_int);
} else {
error = -EXPR_EXPECTING_INT;
}
prev_stat = NADA;
} else if (loadtok(&ident, startptr, &end_ptr)) {
int l_index;
struct expr_var *tmp_var;
if (prev_stat == NADA) {
int kwn = strtoKW(ident);
switch (kwn) {
case KW_VARSET: prev_stat = VARSET; break;
case KW_ARG: prev_stat = ARG; break;
case KW_FULLCLEAR:
error = inject_clear(&outp);
prev_stat = NADA;
break;
case KW_NCLEAR: prev_stat = NCLEAR; break;
default: /* not a kw */
{
struct expr_func *tmp_fn;
struct expr_const *tmp_const;
int l_index;
if ((l_index = strtoLocal(&locals, ident ))
!= _NO_SUCH_LOCAL) {
error = inject_localvar_get(&outp,
l_index);
} else if ((tmp_var = strtoVar(&env->vars,
ident)) != NULL) {
error = inject_globalvar_get(&outp,
tmp_var);
} else if ((tmp_fn = strtoFun(env, ident))
!= NULL) {
error = inject_fn(&outp, tmp_fn);
} else if ((tmp_const = strtoConst(env,
ident)) != NULL) {
error = inject_const(&outp,
tmp_const);
} else {
error = -EXPR_NOSYM;
}
}
}
} else {
if (strtoKW(ident) != NOT_A_KW) {
if (prev_stat == VARSET)
error = -EXPR_EXPECTING_VAR;
else
error = -EXPR_EXPECTING_VALUE;
} else if (prev_stat == VARSET) {
if ((l_index = strtoLocal(&locals, ident ))
!= _NO_SUCH_LOCAL) {
error = inject_localvar_set(&outp,
l_index);
} else if ((tmp_var = strtoVar(&env->vars,
ident)) != NULL) {
error = inject_globalvar_set(&outp,
tmp_var);
} else {
l_index =inject_localvar_setdeclare(
&outp);
if (l_index < 0) {
error = l_index;
} else {
error = ins_local(&locals,
ident, l_index);
}
}
} else {
error = -EXPR_NOSYM;
}
prev_stat = NADA;
}
} else {
error = -EXPR_NOSYM;
}
input_counter += end_ptr - startptr;
if (error != -E_OK) {
ret.pos = input_counter;
ret.lineno = get_lineno(ci);
ret.type = error;
if (ident != NULL) {
ret.fname = ident;
ident = NULL; /* prevent free() */
} else {
ret.fname = strndup(startptr,
end_ptr - startptr);
}
}
free(ident);
}
{
char *bad_string;
switch (ret.type) {
case -EXPR_ARG_OORANGE:
ret.n = query_bad_argument(&outp);
break;
case -EXPR_FEWARGS:
ret.n = query_bf_in(&outp);
ret.m = query_bf_real(&outp);
break;
default: /* <-- includes EXPECTING_STH */
break;
case -E_OK:
{
int nr = query_excess_rets(&outp);
if (!opts.auto_clear && nr > 0)
ret.type = -EXPR_MANYVALUES;
if (ret.type != -E_OK)
ret.n = query_n_rets(&outp);
else if ((*ocode = po_compile(&outp))==NULL)
ret.type = query_status(&outp);
}
break;
}
if (ret.fname == NULL
&& (bad_string = query_bad_fname(&outp)) != NULL) {
ret.fname = strdup(bad_string);
}
}
destroy_locals(&locals);
if (*ocode == NULL) {
po_abort(&outp);
}
return ret;
}
NOEXPORT void init_ssl(CLI *c) {
int i, err;
SSL_SESSION *old_session;
int unsafe_openssl;
c->ssl=SSL_new(c->opt->ctx);
if(!c->ssl) {
sslerror("SSL_new");
longjmp(c->err, 1);
}
SSL_set_ex_data(c->ssl, cli_index, c); /* for callbacks */
if(c->opt->option.client) {
#ifndef OPENSSL_NO_TLSEXT
if(c->opt->sni) {
s_log(LOG_DEBUG, "SNI: sending servername: %s", c->opt->sni);
if(!SSL_set_tlsext_host_name(c->ssl, c->opt->sni)) {
sslerror("SSL_set_tlsext_host_name");
longjmp(c->err, 1);
}
}
#endif
if(c->opt->session) {
enter_critical_section(CRIT_SESSION);
SSL_set_session(c->ssl, c->opt->session);
leave_critical_section(CRIT_SESSION);
}
SSL_set_fd(c->ssl, c->remote_fd.fd);
SSL_set_connect_state(c->ssl);
} else {
if(c->local_rfd.fd==c->local_wfd.fd)
SSL_set_fd(c->ssl, c->local_rfd.fd);
else {
/* does it make sense to have SSL on STDIN/STDOUT? */
SSL_set_rfd(c->ssl, c->local_rfd.fd);
SSL_set_wfd(c->ssl, c->local_wfd.fd);
}
SSL_set_accept_state(c->ssl);
}
/* setup some values for transfer() function */
if(c->opt->option.client) {
c->sock_rfd=&(c->local_rfd);
c->sock_wfd=&(c->local_wfd);
c->ssl_rfd=c->ssl_wfd=&(c->remote_fd);
} else {
c->sock_rfd=c->sock_wfd=&(c->remote_fd);
c->ssl_rfd=&(c->local_rfd);
c->ssl_wfd=&(c->local_wfd);
}
unsafe_openssl=SSLeay()<0x0090810fL ||
(SSLeay()>=0x10000000L && SSLeay()<0x1000002fL);
while(1) {
/* critical section for OpenSSL version < 0.9.8p or 1.x.x < 1.0.0b *
* this critical section is a crude workaround for CVE-2010-3864 *
* see http://www.securityfocus.com/bid/44884 for details *
* alternative solution is to disable internal session caching *
* NOTE: this critical section also covers callbacks (e.g. OCSP) */
if(unsafe_openssl)
enter_critical_section(CRIT_SSL);
if(c->opt->option.client)
i=SSL_connect(c->ssl);
else
i=SSL_accept(c->ssl);
if(unsafe_openssl)
leave_critical_section(CRIT_SSL);
err=SSL_get_error(c->ssl, i);
if(err==SSL_ERROR_NONE)
break; /* ok -> done */
if(err==SSL_ERROR_WANT_READ || err==SSL_ERROR_WANT_WRITE) {
s_poll_init(c->fds);
s_poll_add(c->fds, c->ssl_rfd->fd,
err==SSL_ERROR_WANT_READ,
err==SSL_ERROR_WANT_WRITE);
switch(s_poll_wait(c->fds, c->opt->timeout_busy, 0)) {
case -1:
sockerror("init_ssl: s_poll_wait");
longjmp(c->err, 1);
case 0:
s_log(LOG_INFO, "init_ssl: s_poll_wait:"
" TIMEOUTbusy exceeded: sending reset");
longjmp(c->err, 1);
case 1:
break; /* OK */
default:
s_log(LOG_ERR, "init_ssl: s_poll_wait: unknown result");
longjmp(c->err, 1);
}
continue; /* ok -> retry */
}
if(err==SSL_ERROR_SYSCALL) {
switch(get_last_socket_error()) {
case S_EINTR:
case S_EWOULDBLOCK:
#if S_EAGAIN!=S_EWOULDBLOCK
case S_EAGAIN:
#endif
continue;
}
}
if(c->opt->option.client)
sslerror("SSL_connect");
else
sslerror("SSL_accept");
longjmp(c->err, 1);
}
if(SSL_session_reused(c->ssl)) {
s_log(LOG_INFO, "SSL %s: previous session reused",
c->opt->option.client ? "connected" : "accepted");
} else { /* a new session was negotiated */
new_chain(c);
if(c->opt->option.client) {
s_log(LOG_INFO, "SSL connected: new session negotiated");
enter_critical_section(CRIT_SESSION);
old_session=c->opt->session;
c->opt->session=SSL_get1_session(c->ssl); /* store it */
if(old_session)
SSL_SESSION_free(old_session); /* release the old one */
leave_critical_section(CRIT_SESSION);
} else
s_log(LOG_INFO, "SSL accepted: new session negotiated");
print_cipher(c);
}
}
