static PyObject*
decode_json(JSONData *jsondata)
{
PyObject *object;
skipSpaces(jsondata);
switch(*jsondata->ptr) {
case 0:
PyErr_SetString(JSON_DecodeError, "empty JSON description");
return NULL;
case '{':
object = decode_object(jsondata);
break;
case '[':
object = decode_array(jsondata);
break;
case '"':
object = decode_string(jsondata);
break;
case 't':
case 'f':
object = decode_bool(jsondata);
break;
case 'n':
object = decode_null(jsondata);
break;
case 'N':
object = decode_nan(jsondata);
break;
case 'I':
object = decode_inf(jsondata);
break;
case '+':
case '-':
if (*(jsondata->ptr+1) == 'I') {
object = decode_inf(jsondata);
} else {
object = decode_number(jsondata);
}
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
object = decode_number(jsondata);
break;
default:
PyErr_SetString(JSON_DecodeError, "cannot parse JSON description");
return NULL;
}
return object;
}
int php_deserialize( rabbit * r, rawbuffer * buf, TValue * tv )
{
if(!buf || !tv) {
return -1;
}
setnilvalue(tv);
int c = decode_read_byte( buf );
switch( c ) {
case PHP_NULL:
// kLOG(r, 0,"php decode nil\n");
return decode_null( r, buf, tv );
case PHP_INT:
// kLOG(r, 0,"php decode int\n");
return decode_int( r, buf, tv );
case PHP_DOUBLE:
// kLOG(r, 0,"php decode double\n");
return decode_double(r, buf, tv);
case PHP_STRING:
// kLOG(r, 0,"php decode string\n");
return decode_string(r, buf, tv);
case PHP_ARRAY:
// kLOG(r, 0,"php decode array\n");
return decode_array(r, buf, tv);
case PHP_BOOL:
return decode_bool(r, buf, tv);
default:
kLOG(r, 0, "php decode unknow:%c\n",c);
break;
}
return -1;
}
static VALUE
ossl_asn1_decode0(unsigned char **pp, long length, long *offset, long depth,
int once, int yield)
{
unsigned char *start, *p;
const unsigned char *p0;
long len, off = *offset;
int hlen, tag, tc, j;
VALUE ary, asn1data, value, tag_class;
ary = rb_ary_new();
p = *pp;
while(length > 0){
start = p;
p0 = p;
j = ASN1_get_object(&p0, &len, &tag, &tc, length);
p = (unsigned char *)p0;
if(j & 0x80) ossl_raise(eASN1Error, NULL);
hlen = p - start;
if(yield){
VALUE arg = rb_ary_new();
rb_ary_push(arg, LONG2NUM(depth));
rb_ary_push(arg, LONG2NUM(off));
rb_ary_push(arg, LONG2NUM(hlen));
rb_ary_push(arg, LONG2NUM(len));
rb_ary_push(arg, (j & V_ASN1_CONSTRUCTED) ? Qtrue : Qfalse);
rb_ary_push(arg, ossl_asn1_class2sym(tc));
rb_ary_push(arg, INT2NUM(tag));
rb_yield(arg);
}
length -= hlen;
off += hlen;
if(len > length) ossl_raise(eASN1Error, "value is too short");
if((tc & V_ASN1_PRIVATE) == V_ASN1_PRIVATE)
tag_class = sPRIVATE;
else if((tc & V_ASN1_CONTEXT_SPECIFIC) == V_ASN1_CONTEXT_SPECIFIC)
tag_class = sCONTEXT_SPECIFIC;
else if((tc & V_ASN1_APPLICATION) == V_ASN1_APPLICATION)
tag_class = sAPPLICATION;
else
tag_class = sUNIVERSAL;
if(j & V_ASN1_CONSTRUCTED){
/* TODO: if j == 0x21 it is indefinite length object. */
if((j == 0x21) && (len == 0)){
long lastoff = off;
value = ossl_asn1_decode0(&p, length, &off, depth+1, 0, yield);
len = off - lastoff;
}
else value = ossl_asn1_decode0(&p, len, &off, depth+1, 0, yield);
}
else{
value = rb_str_new((const char *)p, len);
p += len;
off += len;
}
if(tag_class == sUNIVERSAL &&
tag < ossl_asn1_info_size && ossl_asn1_info[tag].klass){
VALUE klass = *ossl_asn1_info[tag].klass;
long flag = 0;
if(!rb_obj_is_kind_of(value, rb_cArray)){
switch(tag){
case V_ASN1_BOOLEAN:
value = decode_bool(start, hlen+len);
break;
case V_ASN1_INTEGER:
value = decode_int(start, hlen+len);
break;
case V_ASN1_BIT_STRING:
value = decode_bstr(start, hlen+len, &flag);
break;
case V_ASN1_NULL:
value = decode_null(start, hlen+len);
break;
case V_ASN1_ENUMERATED:
value = decode_enum(start, hlen+len);
break;
case V_ASN1_OBJECT:
value = decode_obj(start, hlen+len);
break;
case V_ASN1_UTCTIME: /* FALLTHROUGH */
case V_ASN1_GENERALIZEDTIME:
value = decode_time(start, hlen+len);
break;
default:
/* use original value */
break;
}
}
asn1data = rb_funcall(klass, rb_intern("new"), 1, value);
if(tag == V_ASN1_BIT_STRING){
rb_iv_set(asn1data, "@unused_bits", LONG2NUM(flag));
}
}
else{
asn1data = rb_funcall(cASN1Data, rb_intern("new"), 3,
value, INT2NUM(tag), ID2SYM(tag_class));
}
rb_ary_push(ary, asn1data);
length -= len;
if(once) break;
}
*pp = p;
*offset = off;
return ary;
}
static
DBusHandlerResult
profile_tracker_filter(DBusConnection *conn,
DBusMessage *msg,
void *user_data)
{
(void)conn; (void)user_data;
DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
const char *interface = dbus_message_get_interface(msg);
const char *member = dbus_message_get_member(msg);
const char *object = dbus_message_get_path(msg);
int type = dbus_message_get_type(msg);
#if 0
const char *typename = "UNKNOWN";
switch( type )
{
case DBUS_MESSAGE_TYPE_INVALID: typename = "INVALID"; break;
case DBUS_MESSAGE_TYPE_METHOD_CALL: typename = "M-CALL"; break;
case DBUS_MESSAGE_TYPE_METHOD_RETURN: typename = "M-RET"; break;
case DBUS_MESSAGE_TYPE_ERROR: typename = "ERROR"; break;
case DBUS_MESSAGE_TYPE_SIGNAL: typename = "SIGNAL"; break;
}
log_debug("%s: %s, %s, %s\n", typename, interface, object, member);
#endif
if( !interface || !member || !object )
{
goto cleanup;
}
if( type == DBUS_MESSAGE_TYPE_SIGNAL &&
!strcmp(interface, PROFILED_SERVICE) &&
!strcmp(object, PROFILED_PATH) &&
!strcmp(member, PROFILED_CHANGED) )
{
DBusMessageIter iter;
DBusMessageIter item;
int changed = 0;
int active = 0;
const char *profile = 0;
dbus_message_iter_init(msg, &iter);
if( decode_bool(&iter, &changed) || decode_bool(&iter, &active) ||
decode_string(&iter, &profile) )
{
goto cleanup;
}
if( changed != 0 )
{
profile_track_profile(profile);
}
dbus_message_iter_recurse(&iter, &item);
const char *key, *val, *type;
while( decode_triplet(&item, &key,&val,&type) == 0 )
{
if( active != 0 )
{
profile_track_active(profile, key,val,type);
}
else
{
profile_track_change(profile, key,val,type);
}
}
}
cleanup:
return result;
}
