static gboolean
hex (const char *spec,
int len,
unsigned int *c)
{
const char *end;
*c = 0;
for (end = spec + len; spec != end; spec++)
if (g_ascii_isxdigit (*spec))
*c = (*c << 4) | g_ascii_xdigit_value (*spec);
else
return FALSE;
return TRUE;
}
char *
uri_decoded_copy (const char *part, int length)
{
unsigned char *s, *d;
char *decoded = g_strndup (part, length);
g_return_val_if_fail (part != NULL, NULL);
s = d = (unsigned char *)decoded;
do {
if (*s == '%') {
if (!g_ascii_isxdigit (s[1]) ||
!g_ascii_isxdigit (s[2])) {
*d++ = *s;
continue;
}
*d++ = HEXCHAR (s);
s += 2;
} else
*d++ = *s;
} while (*s++);
return decoded;
}
static char *
uri_decoded_copy (const char *part,
gsize length)
{
unsigned char *s, *d;
char *decoded = g_strndup (part, length);
s = d = (unsigned char *)decoded;
do {
if (*s == '%') {
if (!g_ascii_isxdigit (s[1]) ||
!g_ascii_isxdigit (s[2])) {
*d++ = *s;
continue;
}
*d++ = HEXCHAR (s);
s += 2;
} else {
*d++ = *s;
}
} while (*s++);
return decoded;
}
static gboolean
_r_parser_lladdr(guint8 *str, gint *len, gint count, gint parts, gpointer state, RParserMatch *match)
{
gint i;
*len = 0;
for (i = 1; i <= parts; i++)
{
if (!g_ascii_isxdigit(str[*len]) || !g_ascii_isxdigit(str[*len + 1]))
{
if ( i > 1 )
{
(*len) -= 1;
break;
}
else
return FALSE;
}
if (i == parts)
(*len) += 2;
else
{
if (str[*len + 2] != ':')
{
(*len) += 2;
break;
}
else
(*len) += 3;
}
}
if (G_UNLIKELY(*len > count))
return FALSE;
return TRUE;
}
static gboolean
validate (WirelessSecurity *parent, GError **error)
{
WirelessSecurityWEPKey *sec = (WirelessSecurityWEPKey *) parent;
GtkWidget *entry;
const char *key;
int i;
entry = GTK_WIDGET (gtk_builder_get_object (parent->builder, "wep_key_entry"));
g_assert (entry);
key = gtk_entry_get_text (GTK_ENTRY (entry));
if (!key) {
g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("missing wep-key"));
return FALSE;
}
if (sec->type == NM_WEP_KEY_TYPE_KEY) {
if ((strlen (key) == 10) || (strlen (key) == 26)) {
for (i = 0; i < strlen (key); i++) {
if (!g_ascii_isxdigit (key[i])) {
g_set_error (error, NMA_ERROR, NMA_ERROR_GENERIC, _("invalid wep-key: key with a length of %zu must contain only hex-digits"), strlen (key));
return FALSE;
}
}
} else if ((strlen (key) == 5) || (strlen (key) == 13)) {
for (i = 0; i < strlen (key); i++) {
if (!utils_char_is_ascii_print (key[i])) {
g_set_error (error, NMA_ERROR, NMA_ERROR_GENERIC, _("invalid wep-key: key with a length of %zu must contain only ascii characters"), strlen (key));
return FALSE;
}
}
} else {
g_set_error (error, NMA_ERROR, NMA_ERROR_GENERIC, _("invalid wep-key: wrong key length %zu. A key must be either of length 5/13 (ascii) or 10/26 (hex)"), strlen (key));
return FALSE;
}
} else if (sec->type == NM_WEP_KEY_TYPE_PASSPHRASE) {
if (!*key || (strlen (key) > 64)) {
if (!*key)
g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("invalid wep-key: passphrase must be non-empty"));
else
g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("invalid wep-key: passphrase must be shorter than 64 characters"));
return FALSE;
}
}
return TRUE;
}
static guint
get_hex_uint(tvbuff_t *tvb, gint offset, gint *next_offset)
{
int c;
guint u = 0;
while (g_ascii_isxdigit(c = tvb_get_guint8(tvb, offset))) {
u = 16*u + ws_xton(c);
offset++;
}
*next_offset = offset;
return u;
}
static gboolean
hex (const gchar *spec,
gint len,
guint *c)
{
const gchar *end;
*c = 0;
for (end = spec + len; spec != end; spec++) {
if (!g_ascii_isxdigit (*spec))
return FALSE;
*c = (*c << 4) | g_ascii_xdigit_value (*spec);
}
return TRUE;
}
static void
add_ip4_config (GString *str, NMSettingIP4Config *s_ip4, const char *hostname)
{
if (s_ip4) {
const char *tmp;
tmp = nm_setting_ip4_config_get_dhcp_client_id (s_ip4);
if (tmp) {
gboolean is_octets = TRUE;
const char *p = tmp;
while (*p) {
if (!g_ascii_isxdigit (*p) && (*p != ':')) {
is_octets = FALSE;
break;
}
p++;
}
/* If the client ID is just hex digits and : then don't use quotes,
* because dhclient expects either a quoted ASCII string, or a byte
* array formated as hex octets separated by :
*/
if (is_octets)
g_string_append_printf (str, CLIENTID_FORMAT_OCTETS "\n", tmp);
else
g_string_append_printf (str, CLIENTID_FORMAT "\n", tmp);
}
}
add_hostname (str, HOSTNAME4_FORMAT "\n", hostname);
g_string_append_c (str, '\n');
/* Define options for classless static routes */
g_string_append (str,
"option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;\n");
g_string_append (str,
"option ms-classless-static-routes code 249 = array of unsigned integer 8;\n");
/* Web Proxy Auto-Discovery option (bgo #368423) */
g_string_append (str, "option wpad code 252 = string;\n");
g_string_append_c (str, '\n');
}
static int parse_hexstr(const char *str, struct context *ctx)
{
gsize i, j, k, length;
uint8_t value;
char c;
length = strlen(str);
if (!length) {
sr_err("Column %zu in line %zu is empty.", ctx->single_column,
ctx->line_number);
return SR_ERR;
}
/* Clear buffer in order to set bits only. */
memset(ctx->sample_buffer, 0, (ctx->num_probes + 7) >> 3);
/* Calculate the position of the first hexadecimal digit. */
i = ctx->first_probe / 4;
for (j = 0; i < length && j < ctx->num_probes; i++) {
c = str[length - i - 1];
if (!g_ascii_isxdigit(c)) {
sr_err("Invalid value '%s' in column %zu in line %zu.",
str, ctx->single_column, ctx->line_number);
return SR_ERR;
}
value = g_ascii_xdigit_value(c);
k = (ctx->first_probe + j) % 4;
for (; j < ctx->num_probes && k < 4; k++) {
if (value & (1 << k))
ctx->sample_buffer[j / 8] |= (1 << (j % 8));
j++;
}
}
return SR_OK;
}
static gboolean
get_guid(const char *s, e_guid_t *guid)
{
size_t i, n;
const char *p;
char digits[9];
static const char fmt[] = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX";
n = strlen(s);
if (n != strlen(fmt))
return FALSE;
for (i=0; i<n; i++) {
if (fmt[i] == 'X') {
if (!g_ascii_isxdigit(s[i]))
return FALSE;
} else {
if (s[i] != fmt[i])
return FALSE;
}
}
p = s;
strncpy(digits, p, 8);
digits[8] = '\0';
guid->data1 = (guint32)strtoul(digits, NULL, 16);
p += 9;
strncpy(digits, p, 4);
digits[4] = '\0';
guid->data2 = (guint16)strtoul(digits, NULL, 16);
p += 5;
strncpy(digits, p, 4);
digits[4] = '\0';
guid->data3 = (guint16)strtoul(digits, NULL, 16);
p += 5;
for (i=0; i < sizeof(guid->data4); i++) {
if (*p == '-') p++;
digits[0] = *(p++);
digits[1] = *(p++);
digits[2] = '\0';
guid->data4[i] = (guint8)strtoul(digits, NULL, 16);
}
return TRUE;
}
static void
add_ip4_config (GString *str, const char *dhcp_client_id, const char *hostname)
{
if (dhcp_client_id) {
gboolean is_octets = TRUE;
int i = 0;
while (dhcp_client_id[i]) {
if ((i % 3) != 2 && !g_ascii_isxdigit (dhcp_client_id[i])) {
is_octets = FALSE;
break;
}
if ((i % 3) == 2 && dhcp_client_id[i] != ':') {
is_octets = FALSE;
break;
}
i++;
}
/* If the client ID is just hex digits and : then don't use quotes,
* because dhclient expects either a quoted ASCII string, or a byte
* array formated as hex octets separated by :
*/
if (is_octets)
g_string_append_printf (str, CLIENTID_FORMAT_OCTETS "\n", dhcp_client_id);
else
g_string_append_printf (str, CLIENTID_FORMAT "\n", dhcp_client_id);
}
add_hostname (str, HOSTNAME4_FORMAT "\n", hostname);
g_string_append_c (str, '\n');
/* Define options for classless static routes */
g_string_append (str,
"option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;\n");
g_string_append (str,
"option ms-classless-static-routes code 249 = array of unsigned integer 8;\n");
/* Web Proxy Auto-Discovery option (bgo #368423) */
g_string_append (str, "option wpad code 252 = string;\n");
g_string_append_c (str, '\n');
}
/* isdumpline assumes that dump lines start with some non-alphanumerics
* followed by 4 hex numbers - each 8 digits long, each hex number followed
* by 3 spaces.
*/
static int
isdumpline( gchar *line )
{
int i, j;
while (*line && !g_ascii_isalnum(*line))
line++;
for (j=0; j<4; j++) {
for (i=0; i<8; i++, line++)
if (! g_ascii_isxdigit(*line))
return FALSE;
for (i=0; i<3; i++, line++)
if (*line != ' ')
return FALSE;
}
return g_ascii_isspace(*line);
}
static void
_gtk_css_parser_unescape (GtkCssParser *parser,
GString *str)
{
guint i;
gunichar result = 0;
g_assert (*parser->data == '\\');
parser->data++;
for (i = 0; i < 6; i++)
{
if (!g_ascii_isxdigit (parser->data[i]))
break;
result = (result << 4) + get_xdigit (parser->data[i]);
}
if (i != 0)
{
g_string_append_unichar (str, result);
parser->data += i;
/* NB: gtk_css_parser_new_line() forward data pointer itself */
if (!gtk_css_parser_new_line (parser) &&
*parser->data &&
strchr (WHITESPACE_CHARS, *parser->data))
parser->data++;
return;
}
if (gtk_css_parser_new_line (parser))
return;
g_string_append_c (str, *parser->data);
parser->data++;
return;
}
static void
ip_address_filter_cb (GtkEntry * entry,
const gchar *text,
gint length,
gint * position,
gpointer user_data)
{
GtkWidget *ok_button = user_data;
GtkEditable *editable = GTK_EDITABLE (entry);
int i, count = 0;
gchar *result;
result = g_malloc0 (length + 1);
for (i = 0; i < length; i++) {
if (g_ascii_isxdigit(text[i]) || (text[i] == ':'))
result[count++] = text[i];
}
if (count > 0) {
g_signal_handlers_block_by_func (G_OBJECT (editable),
G_CALLBACK (ip_address_filter_cb),
user_data);
gtk_editable_insert_text (editable, result, count, position);
g_free (last_edited);
last_edited = g_strdup (gtk_editable_get_chars (editable, 0, -1));
g_signal_handlers_unblock_by_func (G_OBJECT (editable),
G_CALLBACK (ip_address_filter_cb),
user_data);
}
g_signal_stop_emission_by_name (G_OBJECT (editable), "insert-text");
g_free (result);
/* Desensitize the OK button during input to simplify input validation.
* All routes will be validated on focus-out, which will then re-enable
* the OK button if the routes are valid.
*/
gtk_widget_set_sensitive (ok_button, FALSE);
}
/**
* g_dbus_is_guid:
* @string: The string to check.
*
* Checks if @string is a D-Bus GUID.
*
* See the D-Bus specification regarding what strings are valid D-Bus
* GUID (for example, D-Bus GUIDs are not RFC-4122 compliant).
*
* Returns: %TRUE if @string is a guid, %FALSE otherwise.
*
* Since: 2.26
*/
gboolean
g_dbus_is_guid (const gchar *string)
{
gboolean ret;
guint n;
g_return_val_if_fail (string != NULL, FALSE);
ret = FALSE;
for (n = 0; n < 32; n++)
{
if (!g_ascii_isxdigit (string[n]))
goto out;
}
if (string[32] != '\0')
goto out;
ret = TRUE;
out:
return ret;
}
static const gchar* read_num(const gchar *s, RobotVMWord *result, int line, GError **error)
{
RobotVMWord res = 0;
RobotVMWord r2 = 0;
if (s[0] == '0' && s[1] == 'x') { /* Read hex */
s += 2;
while (g_ascii_isxdigit(*s)) {
r2 = res * 16 + g_ascii_xdigit_value(*s);
++s;
if (r2 < res) {
g_set_error(error, ROBOT_ERROR, ROBOT_ERROR_SYNTAX, "Integer overflow at line %d", line);
return NULL;
}
res = r2;
}
} else {
while (g_ascii_isdigit(*s)) {
r2 = res * 10 + g_ascii_digit_value(*s);
++s;
if (r2 < res) {
g_set_error(error, ROBOT_ERROR, ROBOT_ERROR_SYNTAX, "Integer overflow at line %d", line);
return NULL;
}
res = r2;
}
}
*result = res;
return s;
}
/* uuid_parse does not work for machine-id, so we use our own converter */
static gboolean
machine_id_parse (const char *in, uuid_t uu)
{
const char *cp;
int i;
char buf[3];
g_return_val_if_fail (in != NULL, FALSE);
g_return_val_if_fail (strlen (in) == 32, FALSE);
for (i = 0; i < 32; i++, cp++) {
if (!g_ascii_isxdigit (in[i]))
return FALSE;
}
buf[2] = 0;
cp = in;
for (i = 0; i < 16; i++) {
buf[0] = *cp++;
buf[1] = *cp++;
uu[i] = ((unsigned char) strtoul (buf, NULL, 16)) & 0xFF;
}
return TRUE;
}
static GtkSymbolicColor *
gtk_css_parser_try_hash_color (GtkCssParser *parser)
{
if (parser->data[0] == '#' &&
g_ascii_isxdigit (parser->data[1]) &&
g_ascii_isxdigit (parser->data[2]) &&
g_ascii_isxdigit (parser->data[3]))
{
GdkRGBA rgba;
if (g_ascii_isxdigit (parser->data[4]) &&
g_ascii_isxdigit (parser->data[5]) &&
g_ascii_isxdigit (parser->data[6]))
{
rgba.red = ((get_xdigit (parser->data[1]) << 4) + get_xdigit (parser->data[2])) / 255.0;
rgba.green = ((get_xdigit (parser->data[3]) << 4) + get_xdigit (parser->data[4])) / 255.0;
rgba.blue = ((get_xdigit (parser->data[5]) << 4) + get_xdigit (parser->data[6])) / 255.0;
rgba.alpha = 1.0;
parser->data += 7;
}
else
{
rgba.red = get_xdigit (parser->data[1]) / 15.0;
rgba.green = get_xdigit (parser->data[2]) / 15.0;
rgba.blue = get_xdigit (parser->data[3]) / 15.0;
rgba.alpha = 1.0;
parser->data += 4;
}
_gtk_css_parser_skip_whitespace (parser);
return gtk_symbolic_color_new_literal (&rgba);
}
return NULL;
}
/* Parses a packet record. */
static gboolean
parse_vms_packet(FILE_T fh, wtap_rec *rec, Buffer *buf, int *err, gchar **err_info)
{
char line[VMS_LINE_LENGTH + 1];
int num_items_scanned;
guint32 pkt_len = 0;
int pktnum;
int csec = 101;
struct tm tm;
char mon[4] = {'J', 'A', 'N', 0};
gchar *p;
const gchar *endp;
static const gchar months[] = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";
guint32 i;
int offset = 0;
guint8 *pd;
tm.tm_year = 1970;
tm.tm_mon = 0;
tm.tm_mday = 1;
tm.tm_hour = 1;
tm.tm_min = 1;
tm.tm_sec = 1;
/* Skip lines until one starts with a hex number */
do {
if (file_gets(line, VMS_LINE_LENGTH, fh) == NULL) {
*err = file_error(fh, err_info);
if ((*err == 0) && (csec != 101)) {
*err = WTAP_ERR_SHORT_READ;
}
return FALSE;
}
line[VMS_LINE_LENGTH] = '\0';
if ((csec == 101) && (p = strstr(line, "packet ")) != NULL
&& (! strstr(line, "could not save "))) {
/* Find text in line starting with "packet ". */
/* First look for the Format 1 type sequencing */
num_items_scanned = sscanf(p,
"packet %9d at %2d-%3s-%4d %2d:%2d:%2d.%9d",
&pktnum, &tm.tm_mday, mon,
&tm.tm_year, &tm.tm_hour,
&tm.tm_min, &tm.tm_sec, &csec);
/* Next look for the Format 2 type sequencing */
if (num_items_scanned != 8) {
num_items_scanned = sscanf(p,
"packet seq # = %9d at %2d-%3s-%4d %2d:%2d:%2d.%9d",
&pktnum, &tm.tm_mday, mon,
&tm.tm_year, &tm.tm_hour,
&tm.tm_min, &tm.tm_sec, &csec);
}
/* if unknown format then exit with error */
/* We will need to add code to handle new format */
if (num_items_scanned != 8) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("vms: header line not valid");
return FALSE;
}
}
if ( (! pkt_len) && (p = strstr(line, "Length"))) {
p += sizeof("Length ");
while (*p && ! g_ascii_isdigit(*p))
p++;
if ( !*p ) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("vms: Length field not valid");
return FALSE;
}
if (!ws_strtou32(p, &endp, &pkt_len) || (*endp != '\0' && !g_ascii_isspace(*endp))) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("vms: Length field '%s' not valid", p);
return FALSE;
}
break;
}
} while (! isdumpline(line));
if (pkt_len > WTAP_MAX_PACKET_SIZE_STANDARD) {
/*
* Probably a corrupt capture file; return an error,
* so that our caller doesn't blow up trying to allocate
* space for an immensely-large packet.
*/
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("vms: File has %u-byte packet, bigger than maximum of %u",
pkt_len, WTAP_MAX_PACKET_SIZE_STANDARD);
return FALSE;
}
p = strstr(months, mon);
if (p)
tm.tm_mon = (int) (p - months) / 3;
tm.tm_year -= 1900;
tm.tm_isdst = -1;
rec->rec_type = REC_TYPE_PACKET;
rec->presence_flags = WTAP_HAS_TS;
rec->ts.secs = mktime(&tm);
rec->ts.nsecs = csec * 10000000;
rec->rec_header.packet_header.caplen = pkt_len;
rec->rec_header.packet_header.len = pkt_len;
/* Make sure we have enough room for the packet */
ws_buffer_assure_space(buf, pkt_len);
pd = ws_buffer_start_ptr(buf);
/* Convert the ASCII hex dump to binary data */
for (i = 0; i < pkt_len; i += 16) {
if (file_gets(line, VMS_LINE_LENGTH, fh) == NULL) {
*err = file_error(fh, err_info);
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
return FALSE;
}
line[VMS_LINE_LENGTH] = '\0';
if (i == 0) {
while (! isdumpline(line)) { /* advance to start of hex data */
if (file_gets(line, VMS_LINE_LENGTH, fh) == NULL) {
*err = file_error(fh, err_info);
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
return FALSE;
}
line[VMS_LINE_LENGTH] = '\0';
}
while (line[offset] && !g_ascii_isxdigit(line[offset]))
offset++;
}
if (!parse_single_hex_dump_line(line, pd, i,
offset, pkt_len - i)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("vms: hex dump not valid");
return FALSE;
}
}
/* Avoid TCPIPTRACE-W-BUFFERSFUL, TCPIPtrace could not save n packets.
* errors.
*
* XXX - when we support packet drop report information in the
* Wiretap API, we should parse those lines and return "n" as
* a packet drop count. */
if (!file_gets(line, VMS_LINE_LENGTH, fh)) {
*err = file_error(fh, err_info);
if (*err == 0) {
/* There is no next line, so there's no "TCPIPtrace could not
* save n packets" line; not an error. */
return TRUE;
}
return FALSE;
}
return TRUE;
}
static gboolean
mc_search_regex__replace_handle_esc_seq (const GString * replace_str, const gsize current_pos,
gsize * skip_len, int *ret)
{
char *curr_str = &(replace_str->str[current_pos]);
char c = *(curr_str + 1);
if (replace_str->len > current_pos + 2)
{
if (c == '{')
{
for (*skip_len = 2; /* \{ */
current_pos + *skip_len < replace_str->len
&& *(curr_str + *skip_len) >= '0'
&& *(curr_str + *skip_len) <= '7'; (*skip_len)++);
if (current_pos + *skip_len < replace_str->len && *(curr_str + *skip_len) == '}')
{
(*skip_len)++;
*ret = REPLACE_PREPARE_T_ESCAPE_SEQ;
return FALSE;
}
else
{
*ret = REPLACE_PREPARE_T_NOTHING_SPECIAL;
return TRUE;
}
}
if (c == 'x')
{
*skip_len = 2; /* \x */
c = *(curr_str + 2);
if (c == '{')
{
for (*skip_len = 3; /* \x{ */
current_pos + *skip_len < replace_str->len
&& g_ascii_isxdigit ((guchar) * (curr_str + *skip_len)); (*skip_len)++);
if (current_pos + *skip_len < replace_str->len && *(curr_str + *skip_len) == '}')
{
(*skip_len)++;
*ret = REPLACE_PREPARE_T_ESCAPE_SEQ;
return FALSE;
}
else
{
*ret = REPLACE_PREPARE_T_NOTHING_SPECIAL;
return TRUE;
}
}
else if (!g_ascii_isxdigit ((guchar) c))
{
*skip_len = 2; /* \x without number behind */
*ret = REPLACE_PREPARE_T_NOTHING_SPECIAL;
return FALSE;
}
else
{
c = *(curr_str + 3);
if (!g_ascii_isxdigit ((guchar) c))
*skip_len = 3; /* \xH */
else
*skip_len = 4; /* \xHH */
*ret = REPLACE_PREPARE_T_ESCAPE_SEQ;
return FALSE;
}
}
}
if (strchr ("ntvbrfa", c) != NULL)
{
*skip_len = 2;
*ret = REPLACE_PREPARE_T_ESCAPE_SEQ;
return FALSE;
}
return TRUE;
}
CORBA_Object
CORBA_ORB_string_to_object (CORBA_ORB orb,
const CORBA_char *string,
CORBA_Environment *ev)
{
CORBA_Object retval = CORBA_OBJECT_NIL;
CORBA_unsigned_long len;
GIOPRecvBuffer *buf;
#if defined ENABLE_HTTP
gchar *ior = NULL;
#endif
guchar *tmpbuf;
int i;
if (strncmp (string, "IOR:", strlen("IOR:")) &&
strncmp (string, "corbaloc:", strlen ("corbaloc:")) &&
strncmp (string, "iiop:", strlen ("iiop:")) &&
strncmp (string, "iiops:", strlen ("iiops:")) &&
strncmp (string, "ssliop:", strlen ("ssliop:")) &&
strncmp (string, "uiop:", strlen ("uiop:"))) {
#if defined ENABLE_HTTP
if (matecorba_use_http_iors &&
strstr (string, "://")) {
/* FIXME: this code is a security hazard */
ior = orb_http_resolve (string);
if (!ior) {
/* FIXME, set error minor code
* (vendor's error code) to tell user
* initial location of error, ie my
* local ORB, proxy's ORB, server's
* ORB, etc. */
CORBA_exception_set_system (
ev,
ex_CORBA_BAD_PARAM,
CORBA_COMPLETED_NO);
return CORBA_OBJECT_NIL;
}
string = ior;
} else
#endif
{
CORBA_exception_set_system (
ev,
ex_CORBA_BAD_PARAM,
CORBA_COMPLETED_NO);
return CORBA_OBJECT_NIL;
}
}
if (!strncmp (string, "IOR:", strlen ("IOR:")))
{
string += 4;
len = strlen (string);
while (len > 0 && !g_ascii_isxdigit (string [len - 1]))
len--;
if (len % 2) {
#if defined ENABLE_HTTP
g_free (ior);
#endif
return CORBA_OBJECT_NIL;
}
tmpbuf = g_alloca (len / 2);
for (i = 0; i < len; i += 2)
tmpbuf [i/2] = (g_ascii_xdigit_value (string [i]) << 4) |
g_ascii_xdigit_value (string [i + 1]);
buf = giop_recv_buffer_use_encaps (tmpbuf, len / 2);
if (MateCORBA_demarshal_object (&retval, buf, orb)) {
CORBA_exception_set_system (
ev,
ex_CORBA_MARSHAL,
CORBA_COMPLETED_NO);
retval = CORBA_OBJECT_NIL;
}
giop_recv_buffer_unuse (buf);
#if defined ENABLE_HTTP
g_free (ior);
#endif
return retval;
} else {
return MateCORBA_object_by_corbaloc (orb, string, ev);
}
}
/* Helper for the rfc2253 string parser. */
static const char *
parse_dn_part (struct dn_array_s *array, const char *string)
{
static struct {
const char *label;
const char *oid;
} label_map[] =
{
/* Note: Take care we expect the LABEL not more than 9 bytes
longer than the OID. */
{"EMail", "1.2.840.113549.1.9.1" },
{"T", "2.5.4.12" },
{"GN", "2.5.4.42" },
{"SN", "2.5.4.4" },
{"NameDistinguisher", "0.2.262.1.10.7.20"},
{"ADDR", "2.5.4.16" },
{"BC", "2.5.4.15" },
{"D", "2.5.4.13" },
{"PostalCode", "2.5.4.17" },
{"Pseudo", "2.5.4.65" },
{"SerialNumber", "2.5.4.5" },
{NULL, NULL}
};
const char *s, *s1;
size_t n;
char *p;
int i;
/* Parse attributeType */
for (s = string+1; *s && *s != '='; s++)
;
if (!*s)
return NULL; /* error */
n = s - string;
if (!n)
return NULL; /* empty key */
/* We need to allocate a few bytes more due to the possible mapping
from the shorter OID to the longer label. */
array->key = p = g_try_malloc (n+10);
if (!array->key)
return NULL;
memcpy (p, string, n);
p[n] = 0;
trim_trailing_spaces (p);
if (g_ascii_isdigit (*p))
{
for (i=0; label_map[i].label; i++ )
if ( !strcmp (p, label_map[i].oid) )
{
strcpy (p, label_map[i].label);
break;
}
}
string = s + 1;
if (*string == '#')
{
/* Hexstring. */
string++;
for (s=string; g_ascii_isxdigit (*s); s++)
s++;
n = s - string;
if (!n || (n & 1))
return NULL; /* Empty or odd number of digits. */
n /= 2;
array->value = p = g_try_malloc (n+1);
if (!p)
return NULL;
for (s1=string; n; s1 += 2, n--, p++)
{
*(unsigned char *)p = xtoi_2 (s1);
if (!*p)
*p = 0x01; /* Better print a wrong value than truncating
the string. */
}
*p = 0;
}
else
{
/* Regular v3 quoted string. */
for (n=0, s=string; *s; s++)
{
if (*s == '\\')
{
/* Pair. */
s++;
if (*s == ',' || *s == '=' || *s == '+'
|| *s == '<' || *s == '>' || *s == '#' || *s == ';'
|| *s == '\\' || *s == '\"' || *s == ' ')
n++;
else if (g_ascii_isxdigit (*s) && g_ascii_isxdigit(s[1]))
{
s++;
n++;
}
else
return NULL; /* Invalid escape sequence. */
}
else if (*s == '\"')
return NULL; /* Invalid encoding. */
else if (*s == ',' || *s == '=' || *s == '+'
|| *s == '<' || *s == '>' || *s == ';' )
break;
else
n++;
}
array->value = p = g_try_malloc (n+1);
if (!p)
return NULL;
for (s=string; n; s++, n--)
{
if (*s == '\\')
{
s++;
if (g_ascii_isxdigit (*s))
{
*(unsigned char *)p++ = xtoi_2 (s);
s++;
}
else
*p++ = *s;
}
else
*p++ = *s;
}
*p = 0;
}
return s;
}
GSList*
mono_w32process_get_modules (pid_t pid)
{
#if defined(_AIX)
/* due to procfs, this won't work on i */
GSList *ret = NULL;
FILE *fp;
MonoW32ProcessModule *mod;
struct prmap module;
int i;
fpos64_t curpos;
char pidpath[32]; /* "/proc/<uint64_t max>/map" plus null, rounded */
char libpath[MAXPATHLEN + 1];
char membername[MAXPATHLEN + 1];
char combinedname[(MAXPATHLEN * 2) + 3]; /* lib, member, (), and nul */
sprintf (pidpath, "/proc/%d/map", pid);
if ((fp = fopen(pidpath, "r"))) {
while (fread (&module, sizeof (module), 1, fp) == 1
/* proc(4) declares such a struct to be the array terminator */
&& (module.pr_size != 0 && module.pr_mflags != 0)
&& (module.pr_mflags & MA_READ)) {
fgetpos64 (fp, &curpos); /* save our position */
fseeko (fp, module.pr_pathoff, SEEK_SET);
while ((libpath[i++] = fgetc (fp)));
i = 0;
while ((membername[i++] = fgetc (fp)));
i = 0;
fsetpos64 (fp, &curpos); /* back to normal */
mod = g_new0 (MonoW32ProcessModule, 1);
mod->address_start = module.pr_vaddr;
mod->address_end = module.pr_vaddr + module.pr_size;
mod->address_offset = module.pr_off;
mod->perms = g_strdup ("r--p"); /* XXX? */
/* AIX has what appears to be device, channel and inode information,
* but it's in a string. Try parsing it.
*
* XXX: I believe it's fstype.devno.chano.inode, but I'm uncertain
* as to how that maps out, so I only fill in the inode (like BSD)
*/
sscanf (module.pr_mapname, "%*[^.].%*lu.%*u.%lu", &(mod->inode));
if (membername[0]) {
snprintf(combinedname, MAXPATHLEN, "%s(%s)", libpath, membername);
mod->filename = g_strdup (combinedname);
} else {
mod->filename = g_strdup (libpath);
}
if (g_slist_find_custom (ret, mod, mono_w32process_module_equals) == NULL) {
ret = g_slist_prepend (ret, mod);
} else {
mono_w32process_module_free (mod);
}
}
} else {
mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER_PROCESS, "%s: Can't open process map file for pid %d", __func__, pid);
return NULL;
}
if (ret)
ret = g_slist_reverse (ret);
fclose (fp);
return(ret);
#else
GSList *ret = NULL;
FILE *fp;
MonoW32ProcessModule *mod;
gchar buf[MAXPATHLEN + 1], *p, *endp;
gchar *start_start, *end_start, *prot_start, *offset_start;
gchar *maj_dev_start, *min_dev_start, *inode_start, prot_buf[5];
gpointer address_start, address_end, address_offset;
guint32 maj_dev, min_dev;
guint64 inode;
guint64 device;
fp = open_process_map (pid, "r");
if (!fp) {
mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER_PROCESS, "%s: Can't open process map file for pid %d", __func__, pid);
return NULL;
}
while (fgets (buf, sizeof(buf), fp)) {
p = buf;
while (g_ascii_isspace (*p)) ++p;
start_start = p;
if (!g_ascii_isxdigit (*start_start)) {
continue;
}
address_start = (gpointer)strtoul (start_start, &endp, 16);
p = endp;
if (*p != '-') {
continue;
}
++p;
end_start = p;
if (!g_ascii_isxdigit (*end_start)) {
continue;
}
address_end = (gpointer)strtoul (end_start, &endp, 16);
p = endp;
if (!g_ascii_isspace (*p)) {
continue;
}
while (g_ascii_isspace (*p)) ++p;
prot_start = p;
if (*prot_start != 'r' && *prot_start != '-') {
continue;
}
memcpy (prot_buf, prot_start, 4);
prot_buf[4] = '\0';
while (!g_ascii_isspace (*p)) ++p;
while (g_ascii_isspace (*p)) ++p;
offset_start = p;
if (!g_ascii_isxdigit (*offset_start)) {
continue;
}
address_offset = (gpointer)strtoul (offset_start, &endp, 16);
p = endp;
if (!g_ascii_isspace (*p)) {
continue;
}
while(g_ascii_isspace (*p)) ++p;
maj_dev_start = p;
if (!g_ascii_isxdigit (*maj_dev_start)) {
continue;
}
maj_dev = strtoul (maj_dev_start, &endp, 16);
p = endp;
if (*p != ':') {
continue;
}
++p;
min_dev_start = p;
if (!g_ascii_isxdigit (*min_dev_start)) {
continue;
}
min_dev = strtoul (min_dev_start, &endp, 16);
p = endp;
if (!g_ascii_isspace (*p)) {
continue;
}
while (g_ascii_isspace (*p)) ++p;
inode_start = p;
if (!g_ascii_isxdigit (*inode_start)) {
continue;
}
inode = (guint64)strtol (inode_start, &endp, 10);
p = endp;
if (!g_ascii_isspace (*p)) {
continue;
}
#if defined(MAJOR_IN_MKDEV) || defined(MAJOR_IN_SYSMACROS)
device = makedev ((int)maj_dev, (int)min_dev);
#else
device = 0;
#endif
if ((device == 0) && (inode == 0)) {
continue;
}
while(g_ascii_isspace (*p)) ++p;
/* p now points to the filename */
mod = g_new0 (MonoW32ProcessModule, 1);
mod->address_start = address_start;
mod->address_end = address_end;
mod->perms = g_strdup (prot_buf);
mod->address_offset = address_offset;
mod->device = device;
mod->inode = inode;
mod->filename = g_strdup (g_strstrip (p));
if (g_slist_find_custom (ret, mod, mono_w32process_module_equals) == NULL) {
ret = g_slist_prepend (ret, mod);
} else {
mono_w32process_module_free (mod);
}
}
ret = g_slist_reverse (ret);
fclose (fp);
return(ret);
#endif
}
static int
append_hex_digits(char *ascii_buf, int ascii_offset, int max_offset,
char *data, int *err, gchar **err_info)
{
int in_offset, out_offset;
int c;
unsigned int i;
gboolean overflow = FALSE;
in_offset = 0;
out_offset = ascii_offset;
for (;;)
{
/*
* Process a block of up to 16 hex digits.
* The block is terminated early by an end-of-line indication (NUL,
* CR, or LF), by a space (which terminates the last block of the
* data we're processing), or by a "*", which introduces the ASCII representation
* of the data.
* All characters in the block must be upper-case hex digits;
* there might or might not be a space *after* a block, but, if so,
* that will be skipped over after the block is processed.
*/
for (i = 0; i < 16; i++, in_offset++)
{
/*
* If we see an end-of-line indication, or an early-end-of-block
* indication (space), we're done. (Only the last block ends
* early.)
*/
c = data[in_offset] & 0xFF;
if (c == '\0' || c == ' ' || c == '*' || c == '\r' || c == '\n')
{
goto done;
}
if (!g_ascii_isxdigit(c) || g_ascii_islower(c))
{
/*
* Not a hex digit, or a lower-case hex digit.
* Treat this as an indication that the line isn't a data
* line, so we just ignore it.
*
* XXX - do so only for continuation lines; treat non-hex-digit
* characters as errors for other lines?
*/
return ascii_offset; /* pretend we appended nothing */
}
if (out_offset >= max_offset)
overflow = TRUE;
else
{
ascii_buf[out_offset] = c;
out_offset++;
}
}
/*
* Skip blanks, if any.
*/
for (; (data[in_offset] & 0xFF) == ' '; in_offset++)
;
}
done:
/*
* If we processed an *odd* number of hex digits, report an error.
*/
if ((i % 2) != 0)
{
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("iseries: odd number of hex digits in a line");
return -1;
}
if (overflow)
{
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("iseries: more packet data than the packet length indicated");
return -1;
}
return out_offset;
}
static char *
uri_normalized_copy (const char *part, int length,
const char *unescape_extra)
{
unsigned char *s, *d, c;
char *normalized = g_strndup (part, length);
gboolean need_fixup = FALSE;
if (!unescape_extra)
unescape_extra = "";
s = d = (unsigned char *)normalized;
while (*s) {
if (*s == '%') {
if (!g_ascii_isxdigit (s[1]) ||
!g_ascii_isxdigit (s[2])) {
*d++ = *s++;
continue;
}
c = HEXCHAR (s);
if (soup_char_is_uri_unreserved (c) ||
(c && strchr (unescape_extra, c))) {
*d++ = c;
s += 3;
} else {
/* We leave it unchanged. We used to uppercase percent-encoded
* triplets but we do not do it any more as RFC3986 Section 6.2.2.1
* says that they only SHOULD be case normalized.
*/
*d++ = *s++;
*d++ = *s++;
*d++ = *s++;
}
} else {
if (!g_ascii_isgraph (*s) &&
!strchr (unescape_extra, *s))
need_fixup = TRUE;
*d++ = *s++;
}
}
*d = '\0';
if (need_fixup) {
GString *fixed;
fixed = g_string_new (NULL);
s = (guchar *)normalized;
while (*s) {
if (g_ascii_isgraph (*s) ||
strchr (unescape_extra, *s))
g_string_append_c (fixed, *s);
else
g_string_append_printf (fixed, "%%%02X", (int)*s);
s++;
}
g_free (normalized);
normalized = g_string_free (fixed, FALSE);
}
return normalized;
}
static gboolean
parse_dbs_etherwatch_packet(wtap_rec *rec, FILE_T fh, Buffer* buf,
int *err, gchar **err_info)
{
guint8 *pd;
char line[DBS_ETHERWATCH_LINE_LENGTH];
int num_items_scanned;
int eth_hdr_len, pkt_len, csec;
int length_pos, length_from, length;
struct tm tm;
char mon[4] = "xxx";
gchar *p;
static const gchar months[] = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";
int count, line_count;
/* Make sure we have enough room for a regular Ethernet packet */
ws_buffer_assure_space(buf, DBS_ETHERWATCH_MAX_ETHERNET_PACKET_LEN);
pd = ws_buffer_start_ptr(buf);
eth_hdr_len = 0;
memset(&tm, 0, sizeof(tm));
/* Our file pointer should be on the first line containing the
* summary information for a packet. Read in that line and
* extract the useful information
*/
if (file_gets(line, DBS_ETHERWATCH_LINE_LENGTH, fh) == NULL) {
*err = file_error(fh, err_info);
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
return FALSE;
}
/* Get the destination address */
p = strstr(line, DEST_MAC_PREFIX);
if(!p) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: destination address not found");
return FALSE;
}
p += strlen(DEST_MAC_PREFIX);
if(parse_hex_dump(p, &pd[eth_hdr_len], HEX_HDR_SPR, HEX_HDR_END)
!= MAC_ADDR_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: destination address not valid");
return FALSE;
}
eth_hdr_len += MAC_ADDR_LENGTH;
/* Get the source address */
/*
* Since the first part of the line is already skipped in order to find
* the start of the record we cannot index, just look for the first
* 'HEX' character
*/
p = line;
while(!g_ascii_isxdigit(*p)) {
p++;
}
if(parse_hex_dump(p, &pd[eth_hdr_len], HEX_HDR_SPR,
HEX_HDR_END) != MAC_ADDR_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: source address not valid");
return FALSE;
}
eth_hdr_len += MAC_ADDR_LENGTH;
/* Read the next line of the record header */
if (file_gets(line, DBS_ETHERWATCH_LINE_LENGTH, fh) == NULL) {
*err = file_error(fh, err_info);
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
return FALSE;
}
/* Check the lines is as least as long as the length position */
if(strlen(line) < LENGTH_POS) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: line too short");
return FALSE;
}
num_items_scanned = sscanf(line + LENGTH_POS,
"%9d byte buffer at %2d-%3s-%4d %2d:%2d:%2d.%9d",
&pkt_len,
&tm.tm_mday, mon,
&tm.tm_year, &tm.tm_hour, &tm.tm_min,
&tm.tm_sec, &csec);
if (num_items_scanned != 8) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: header line not valid");
return FALSE;
}
if (pkt_len < 0) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: packet header has a negative packet length");
return FALSE;
}
/* Determine whether it is Ethernet II or IEEE 802 */
if(strncmp(&line[ETH_II_CHECK_POS], ETH_II_CHECK_STR,
strlen(ETH_II_CHECK_STR)) == 0) {
/* Ethernet II */
/* Get the Protocol */
if(parse_hex_dump(&line[PROTOCOL_POS], &pd[eth_hdr_len], HEX_HDR_SPR,
HEX_HDR_END) != PROTOCOL_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: Ethernet II protocol value not valid");
return FALSE;
}
eth_hdr_len += PROTOCOL_LENGTH;
} else {
/* IEEE 802 */
/* Remember where to put the length in the header */
length_pos = eth_hdr_len;
/* Leave room in the header for the length */
eth_hdr_len += IEEE802_LEN_LEN;
/* Remember how much of the header should not be added to the length */
length_from = eth_hdr_len;
/* Get the DSAP + SSAP */
if(parse_hex_dump(&line[SAP_POS], &pd[eth_hdr_len], HEX_HDR_SPR,
HEX_HDR_END) != SAP_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: 802.2 DSAP+SSAP value not valid");
return FALSE;
}
eth_hdr_len += SAP_LENGTH;
/* Get the (first part of the) control field */
if(parse_hex_dump(&line[CTL_POS], &pd[eth_hdr_len], HEX_HDR_SPR,
HEX_HDR_END) != CTL_UNNUMB_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: 802.2 control field first part not valid");
return FALSE;
}
/* Determine whether the control is numbered, and thus longer */
if((pd[eth_hdr_len] & CTL_UNNUMB_MASK) != CTL_UNNUMB_VALUE) {
/* Get the rest of the control field, the first octet in the PID */
if(parse_hex_dump(&line[PID_POS],
&pd[eth_hdr_len + CTL_UNNUMB_LENGTH], HEX_HDR_END,
HEX_HDR_SPR) != CTL_NUMB_LENGTH - CTL_UNNUMB_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: 802.2 control field second part value not valid");
return FALSE;
}
eth_hdr_len += CTL_NUMB_LENGTH;
} else {
eth_hdr_len += CTL_UNNUMB_LENGTH;
}
/* Determine whether it is SNAP */
if(strncmp(&line[SNAP_CHECK_POS], SNAP_CHECK_STR,
strlen(SNAP_CHECK_STR)) == 0) {
/* Get the PID */
if(parse_hex_dump(&line[PID_POS], &pd[eth_hdr_len], HEX_HDR_SPR,
HEX_PID_END) != PID_LENGTH) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: 802.2 PID value not valid");
return FALSE;
}
eth_hdr_len += PID_LENGTH;
}
/* Write the length in the header */
length = eth_hdr_len - length_from + pkt_len;
pd[length_pos] = (length) >> 8;
pd[length_pos+1] = (length) & 0xFF;
}
rec->rec_type = REC_TYPE_PACKET;
rec->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN;
p = strstr(months, mon);
if (p)
tm.tm_mon = (int)(p - months) / 3;
tm.tm_year -= 1900;
tm.tm_isdst = -1;
rec->ts.secs = mktime(&tm);
rec->ts.nsecs = csec * 10000000;
rec->rec_header.packet_header.caplen = eth_hdr_len + pkt_len;
rec->rec_header.packet_header.len = eth_hdr_len + pkt_len;
if (rec->rec_header.packet_header.caplen > WTAP_MAX_PACKET_SIZE_STANDARD) {
/*
* Probably a corrupt capture file; return an error,
* so that our caller doesn't blow up trying to allocate
* space for an immensely-large packet.
*/
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("dbs_etherwatch: File has %u-byte packet, bigger than maximum of %u",
rec->rec_header.packet_header.caplen, WTAP_MAX_PACKET_SIZE_STANDARD);
return FALSE;
}
/* Make sure we have enough room, even for an oversized Ethernet packet */
ws_buffer_assure_space(buf, rec->rec_header.packet_header.caplen);
pd = ws_buffer_start_ptr(buf);
/*
* We don't have an FCS in this frame.
*/
rec->rec_header.packet_header.pseudo_header.eth.fcs_len = 0;
/* Parse the hex dump */
count = 0;
while (count < pkt_len) {
if (file_gets(line, DBS_ETHERWATCH_LINE_LENGTH, fh) == NULL) {
*err = file_error(fh, err_info);
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
return FALSE;
}
if (!(line_count = parse_single_hex_dump_line(line,
&pd[eth_hdr_len + count], count))) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: packet data value not valid");
return FALSE;
}
count += line_count;
if (count > pkt_len) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("dbs_etherwatch: packet data value has too many bytes");
return FALSE;
}
}
return TRUE;
}
/*FUNCTION:------------------------------------------------------
* NAME
* zbee_security_parse_key
* DESCRIPTION
* Parses a key string from left to right into a buffer with
* increasing (normal byte order) or decreasing (reverse byte
* order) address.
* PARAMETERS
* const gchar *key_str - pointer to the string
* guint8 *key_buf - destination buffer in memory
* gboolean big_end - fill key_buf with incrementing address
* RETURNS
* gboolean
*---------------------------------------------------------------
*/
static gboolean
zbee_security_parse_key(const gchar *key_str, guint8 *key_buf, gboolean byte_order)
{
int i, j;
gchar temp;
gboolean string_mode = FALSE;
/* Clear the key. */
memset(key_buf, 0, ZBEE_SEC_CONST_KEYSIZE);
if (key_str == NULL) {
return FALSE;
}
/*
* Attempt to parse the key string. The key string must
* be at least 16 pairs of hexidecimal digits with the
* following optional separators: ':', '-', " ", or 16
* alphanumeric characters after a double-quote.
*/
if ( (temp = *key_str++) == '"') {
string_mode = TRUE;
temp = *key_str++;
}
j = byte_order?ZBEE_SEC_CONST_KEYSIZE-1:0;
for (i=ZBEE_SEC_CONST_KEYSIZE-1; i>=0; i--) {
if ( string_mode ) {
if ( g_ascii_isprint(temp) ) {
key_buf[j] = temp;
temp = *key_str++;
} else {
return FALSE;
}
}
else {
/* If this character is a separator, skip it. */
if ( (temp == ':') || (temp == '-') || (temp == ' ') ) temp = *(key_str++);
/* Process a nibble. */
if ( g_ascii_isxdigit (temp) ) key_buf[j] = g_ascii_xdigit_value(temp)<<4;
else return FALSE;
/* Get the next nibble. */
temp = *(key_str++);
/* Process another nibble. */
if ( g_ascii_isxdigit (temp) ) key_buf[j] |= g_ascii_xdigit_value(temp);
else return FALSE;
/* Get the next nibble. */
temp = *(key_str++);
}
/* Move key_buf pointer */
if ( byte_order ) {
j--;
} else {
j++;
}
} /* for */
/* If we get this far, then the key was good. */
return TRUE;
} /* zbee_security_parse_key */
static GByteArray *
parse_old_openssl_key_file (const GByteArray *contents,
int key_type,
char **out_cipher,
char **out_iv,
GError **error)
{
GByteArray *bindata = NULL;
char **lines = NULL;
char **ln = NULL;
gsize start = 0, end = 0;
GString *str = NULL;
int enc_tags = 0;
char *iv = NULL;
char *cipher = NULL;
unsigned char *tmp = NULL;
gsize tmp_len = 0;
const char *start_tag;
const char *end_tag;
guint8 save_end = 0;
switch (key_type) {
case NM_CRYPTO_KEY_TYPE_RSA:
start_tag = PEM_RSA_KEY_BEGIN;
end_tag = PEM_RSA_KEY_END;
break;
case NM_CRYPTO_KEY_TYPE_DSA:
start_tag = PEM_DSA_KEY_BEGIN;
end_tag = PEM_DSA_KEY_END;
break;
default:
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_UNKNOWN_KEY_TYPE,
"Unknown key type %d",
key_type);
g_assert_not_reached ();
return NULL;
}
if (!find_tag (start_tag, contents, 0, &start))
goto parse_error;
start += strlen (start_tag);
if (!find_tag (end_tag, contents, start, &end)) {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
_("PEM key file had no end tag '%s'."),
end_tag);
goto parse_error;
}
save_end = contents->data[end];
contents->data[end] = '\0';
lines = g_strsplit ((const char *) (contents->data + start), "\n", 0);
contents->data[end] = save_end;
if (!lines || g_strv_length (lines) <= 1) {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
_("Doesn't look like a PEM private key file."));
goto parse_error;
}
str = g_string_new_len (NULL, end - start);
for (ln = lines; *ln; ln++) {
char *p = *ln;
/* Chug leading spaces */
p = g_strstrip (p);
if (!*p)
continue;
if (!strncmp (p, PROC_TYPE_TAG, strlen (PROC_TYPE_TAG))) {
if (enc_tags++ != 0) {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
_("Malformed PEM file: Proc-Type was not first tag."));
goto parse_error;
}
p += strlen (PROC_TYPE_TAG);
if (strcmp (p, "4,ENCRYPTED")) {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
_("Malformed PEM file: unknown Proc-Type tag '%s'."),
p);
goto parse_error;
}
} else if (!strncmp (p, DEK_INFO_TAG, strlen (DEK_INFO_TAG))) {
char *comma;
if (enc_tags++ != 1) {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
_("Malformed PEM file: DEK-Info was not the second tag."));
goto parse_error;
}
p += strlen (DEK_INFO_TAG);
/* Grab the IV first */
comma = strchr (p, ',');
if (!comma || (*(comma + 1) == '\0')) {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
_("Malformed PEM file: no IV found in DEK-Info tag."));
goto parse_error;
}
*comma++ = '\0';
if (!g_ascii_isxdigit (*comma)) {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
_("Malformed PEM file: invalid format of IV in DEK-Info tag."));
goto parse_error;
}
iv = g_strdup (comma);
/* Get the private key cipher */
if (!strcasecmp (p, "DES-EDE3-CBC")) {
cipher = g_strdup (p);
} else if (!strcasecmp (p, "DES-CBC")) {
cipher = g_strdup (p);
} else if (!strcasecmp (p, "AES-128-CBC")) {
cipher = g_strdup (p);
} else {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_UNKNOWN_KEY_TYPE,
_("Malformed PEM file: unknown private key cipher '%s'."),
p);
goto parse_error;
}
} else {
if ((enc_tags != 0) && (enc_tags != 2)) {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
"Malformed PEM file: both Proc-Type and DEK-Info tags are required.");
goto parse_error;
}
g_string_append (str, p);
}
}
tmp = g_base64_decode (str->str, &tmp_len);
if (tmp == NULL || !tmp_len) {
g_set_error (error, NM_CRYPTO_ERROR,
NM_CRYPTO_ERR_DECODE_FAILED,
_("Could not decode private key."));
goto parse_error;
}
g_string_free (str, TRUE);
if (lines)
g_strfreev (lines);
bindata = g_byte_array_sized_new (tmp_len);
g_byte_array_append (bindata, tmp, tmp_len);
g_free (tmp);
*out_iv = iv;
*out_cipher = cipher;
return bindata;
parse_error:
g_free (tmp);
g_free (cipher);
g_free (iv);
if (str)
g_string_free (str, TRUE);
if (lines)
g_strfreev (lines);
return NULL;
}
int
is_hex(const char *c)
{
return g_ascii_isxdigit(*c);
}
gboolean
r_parser_ipv6(guint8 *str, gint *len, const gchar *param, gpointer state, RParserMatch *match)
{
gint colons = 0;
gint dots = 0;
gint octet = 0;
gint digit = 16;
gboolean shortened = FALSE;
*len = 0;
while (1)
{
if (str[*len] == ':')
{
if (G_UNLIKELY(octet > 0xffff || (octet == -1 && shortened) || digit == 10))
return FALSE;
if (octet == -1)
shortened = TRUE;
if (G_UNLIKELY(colons == 7))
break;
colons++;
octet = -1;
}
else if (g_ascii_isxdigit(str[*len]))
{
if (octet == -1)
octet = 0;
else
octet *= digit;
octet += g_ascii_xdigit_value(str[*len]);
}
else if (str[*len] == '.')
{
if (G_UNLIKELY((digit == 10 && octet > 255)))
return FALSE;
if (G_UNLIKELY((digit == 16 && octet > 597) || octet == -1 || colons == 7 || dots == 3))
break;
dots++;
octet = -1;
digit = 10;
}
else
break;
(*len)++;
}
if (G_UNLIKELY(str[*len - 1] == '.'))
{
(*len)--;
dots--;
}
else if (G_UNLIKELY(str[*len - 1] == ':' && str[*len - 2] != ':'))
{
(*len)--;
colons--;
}
if (colons < 2 || colons > 7 || (digit == 10 && octet > 255) || (digit == 16 && octet > 0xffff) ||
!(dots == 0 || dots == 3) || (!shortened && colons < 7 && dots == 0))
return FALSE;
return TRUE;
}
