Ewk_JS_Object* ewk_js_object_new(const Ewk_JS_Class_Meta* jsMetaClass)
{
#if ENABLE(NETSCAPE_PLUGIN_API)
Ewk_JS_Object* object;
EINA_SAFETY_ON_NULL_RETURN_VAL(jsMetaClass, 0);
object = static_cast<Ewk_JS_Object*>(malloc(sizeof(Ewk_JS_Object)));
if (!object) {
ERR("Could not allocate memory for ewk_js_object");
return 0;
}
EINA_MAGIC_SET(object, EWK_JS_OBJECT_MAGIC);
object->cls = ewk_js_class_new(jsMetaClass);
object->view = 0;
object->name = 0;
object->type = EWK_JS_OBJECT_OBJECT;
if (eina_hash_population(object->cls->properties) < 25)
object->properties = eina_hash_string_small_new(reinterpret_cast<Eina_Free_Cb>(ewk_js_variant_free));
else
object->properties = eina_hash_string_superfast_new(reinterpret_cast<Eina_Free_Cb>(ewk_js_variant_free));
for (int i = 0; object->cls->meta->properties && object->cls->meta->properties[i].name; i++) {
Ewk_JS_Property prop = object->cls->meta->properties[i];
const char* key = object->cls->meta->properties[i].name;
Ewk_JS_Variant* value = static_cast<Ewk_JS_Variant*>(malloc(sizeof(Ewk_JS_Variant)));
if (!value) {
ERR("Could not allocate memory for ewk_js_variant");
goto error;
}
if (prop.get)
prop.get(object, key, value);
else {
value->type = prop.value.type;
switch (value->type) {
case EWK_JS_VARIANT_VOID:
case EWK_JS_VARIANT_NULL:
value->value.o = 0;
break;
case EWK_JS_VARIANT_STRING:
value->value.s = eina_stringshare_add(prop.value.value.s);
break;
case EWK_JS_VARIANT_BOOL:
value->value.b = prop.value.value.b;
break;
case EWK_JS_VARIANT_INT32:
value->value.i = prop.value.value.i;
break;
case EWK_JS_VARIANT_DOUBLE:
value->value.d = prop.value.value.d;
break;
case EWK_JS_VARIANT_OBJECT:
value->value.o = prop.value.value.o;
break;
}
}
eina_hash_add(object->properties, key, value);
}
object->base.object.referenceCount = 1;
object->base.object._class = &EWK_NPCLASS;
return object;
error:
ewk_js_object_free(object);
return 0;
#else
UNUSED_PARAM(jsMetaClass);
return 0;
#endif
}
EAPI Eolian_Function_Type
eolian_function_type_get(const Eolian_Function *fid)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EOLIAN_UNRESOLVED);
return fid->type;
}
EAPI unsigned int
efreet_desktop_category_count_get(Efreet_Desktop *desktop)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(desktop, 0);
return eina_list_count(desktop->categories);
}
EAPI const Eolian_Implement *
eolian_function_implement_get(const Eolian_Function *fid)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
return fid->impl;
}
EAPI Eina_Bool
eolian_function_object_is_const(const Eolian_Function *fid)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EINA_FALSE);
return fid->obj_is_const;
}
const char* ewk_context_menu_item_title_set(Ewk_Context_Menu_Item* o, const char* title)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(o, 0);
eina_stringshare_replace(&o->title, title);
return o->title;
}
Eina_Bool ewk_context_menu_item_enabled_set(Ewk_Context_Menu_Item *o, Eina_Bool enabled)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(o, EINA_FALSE);
o->enabled = enabled;
return EINA_TRUE;
}
EAPI Eolian_Typedecl_Type
eolian_typedecl_type_get(const Eolian_Typedecl *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, EOLIAN_TYPEDECL_UNKNOWN);
return tp->type;
}
EAPI Eina_Bool
eolian_typedecl_is_extern(const Eolian_Typedecl *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, EINA_FALSE);
return tp->is_extern;
}
EAPI const Eolian_Type *
eolian_typedecl_base_type_get(const Eolian_Typedecl *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, NULL);
return tp->base_type;
}
EAPI Eina_Bool
eolian_type_is_ptr(const Eolian_Type *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, EINA_FALSE);
return tp->is_ptr;
}
EAPI Eolian_Type_Builtin_Type
eolian_type_builtin_type_get(const Eolian_Type *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, EOLIAN_TYPE_BUILTIN_INVALID);
return tp->btype;
}
EAPI const Eolian_Type *
eolian_type_next_type_get(const Eolian_Type *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, NULL);
return tp->next_type;
}
EAPI const Eolian_Documentation *
eolian_typedecl_documentation_get(const Eolian_Typedecl *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, NULL);
return tp->doc;
}
Eina_Bool ewk_context_menu_item_action_set(Ewk_Context_Menu_Item* o, Ewk_Context_Menu_Action action)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(o, EINA_FALSE);
o->action = action;
return EINA_TRUE;
}
EAPI Eina_Stringshare *
eolian_typedecl_free_func_get(const Eolian_Typedecl *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, NULL);
return tp->freefunc;
}
const char* ewk_context_menu_item_title_get(Ewk_Context_Menu_Item* o)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(o, 0);
return o->title;
}
EAPI const Eolian_Documentation *
eolian_typedecl_struct_field_documentation_get(const Eolian_Struct_Type_Field *fl)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(fl, NULL);
return fl->doc;
}
Eina_Bool ewk_context_menu_item_enabled_get(Ewk_Context_Menu_Item* o)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(o, EINA_FALSE);
return o->enabled;
}
EAPI const Eolian_Type *
eolian_typedecl_struct_field_type_get(const Eolian_Struct_Type_Field *fl)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(fl, NULL);
return fl->type;
}
const Eina_List* ewk_context_menu_item_list_get(Ewk_Context_Menu* o)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(o, 0);
return o->items;
}
EAPI Eolian_Type_Type
eolian_type_type_get(const Eolian_Type *tp)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, EOLIAN_TYPE_UNKNOWN_TYPE);
return tp->type;
}
EAPI Eina_Bool
eolian_function_is_class(const Eolian_Function *fid)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EINA_FALSE);
return fid->is_class;
}
Ewk_Context_Menu_Item_Type ewk_context_menu_item_type_get(Ewk_Context_Menu_Item* o)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(o, EWK_ACTION_TYPE);
return o->type;
}
EAPI const Eolian_Class *
eolian_function_class_get(const Eolian_Function *fid)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
return fid->klass;
}
Eina_Bool ewk_context_menu_item_type_set(Ewk_Context_Menu_Item* o, Ewk_Context_Menu_Item_Type type)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(o, EINA_FALSE);
o->type = type;
return EINA_TRUE;
}
char *
esql_string_escape(Eina_Bool backslashes,
const char *s)
{
char *ret, *rp;
const char *p;
if (!s) return NULL;
ret = malloc(sizeof(char) * strlen(s) * 2 + 1);
EINA_SAFETY_ON_NULL_RETURN_VAL(ret, NULL);
if (!backslashes) /* no backslashes allowed, so just double up single quotes */
{
for (p = s, rp = ret; *p; p++, rp++)
{
if (*p == '\'')
{
*rp = '\'';
rp++;
}
*rp = *p;
}
}
else
{
for (p = s, rp = ret; *p; p++, rp++)
{
char e = 0;
switch (*p)
{
case '\'':
case '\\':
case '"':
e = *p;
break;
case '\n':
e = 'n';
break;
case '\r':
e = 'r';
break;
case '\0':
e = '0';
break;
default:
*rp = *p;
continue;
}
*rp++ = '\\';
*rp = e;
}
}
*rp = 0;
return ret;
}
Ewk_Context_Menu_Action ewk_context_menu_item_action_get(Ewk_Context_Menu_Item* o)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(o, EWK_CONTEXT_MENU_ITEM_TAG_NO_ACTION);
return o->action;
}
EAPI void *
efreet_desktop_type_data_get(Efreet_Desktop *desktop)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(desktop, NULL);
return desktop->type_data;
}
Eina_Bool
azy_events_header_parse(Azy_Net *net,
unsigned char *event_data,
size_t event_len,
int offset)
{
unsigned char *r = NULL, *p = NULL, *start = NULL, *buf_start = NULL;
unsigned char *data = (event_data) ? event_data + offset : NULL;
int64_t len = (event_len) ? event_len - offset : 0;
const char *s = NULL;
unsigned char slen = 0;
unsigned char sep[5];
int line_len = 0;
int64_t prev_size = 0;
DBG("(net=%p, event_data=%p, len=%zu, offset=%i)", net, event_data, event_len, offset);
if (!AZY_MAGIC_CHECK(net, AZY_MAGIC_NET))
{
AZY_MAGIC_FAIL(net, AZY_MAGIC_NET);
return EINA_FALSE;
}
if (net->headers_read)
return EINA_TRUE;
EINA_SAFETY_ON_TRUE_RETURN_VAL((!net->buffer) && (!data), EINA_FALSE);
if (net->size && net->buffer)
{
if (event_data && (azy_rpc_log_dom >= 0))
{
char buf[64];
snprintf(buf, sizeof(buf), "STORED:\n<<<<<<<<<<<<<\n%%.%llis\n<<<<<<<<<<<<<", net->size);
RPC_INFO(buf, net->buffer);
snprintf(buf, sizeof(buf), "RECEIVED:\n<<<<<<<<<<<<<\n%%.%llis\n<<<<<<<<<<<<<", len - offset);
RPC_INFO(buf, data);
}
/* previous buffer */
/* alloca should be safe here because ecore_con reads at most 64k
* and even if no headers were found previously, the entire
* buffer would not be copied
*/
buf_start = alloca(len + net->size - offset);
/* grab and combine buffers */
if (event_data)
{
memcpy(buf_start, net->buffer + offset, net->size - offset);
memcpy(buf_start + net->size, event_data, len);
}
else
memcpy(buf_start, net->buffer + offset, net->size - offset);
free(net->buffer);
net->buffer = NULL;
len += net->size - offset;
prev_size = net->size;
net->size = 0;
start = buf_start;
AZY_SKIP_BLANK(start);
}
else
/* only current buffer plus possible net->overflow */
{
/* copy pointer */
start = data;
/* skip all spaces/newlines/etc and decrement len */
AZY_SKIP_BLANK(start);
}
if ((!len) && (event_len - offset > 0)) /* only blanks were passed, assume http separator */
{
net->headers_read = EINA_TRUE;
return EINA_TRUE;
}
/* apparently this can happen? */
EINA_SAFETY_ON_NULL_RETURN_VAL(start, EINA_FALSE);
/* find a header or append to buffer */
if ((!(r = memchr(start, '\r', len)) && !(r = memchr(start, '\n', len)))) /* append to a buffer and use net->overflow */
{
unsigned char *tmp;
if (net->size)
{
tmp = realloc(net->buffer, net->size + len);
EINA_SAFETY_ON_NULL_RETURN_VAL(tmp, EINA_FALSE);
net->buffer = tmp;
memcpy(net->buffer + net->size, start, len);
net->size += len;
}
else
{
tmp = realloc(net->buffer, len);
EINA_SAFETY_ON_NULL_RETURN_VAL(tmp, EINA_FALSE);
net->buffer = tmp;
memcpy(net->buffer, start, len);
net->size = len;
}
return EINA_TRUE;
}
if (*r == '\r')
{
unsigned char *x;
if ((x = memchr(start, '\n', len)))
{
if ((x - r) > 0)
s = "\r\n";
else
{ /* we currently have \n\r: b64 encoding can leave a trailing \n
* so we have to check for an extra \n
*/
if ((x - r < 0) && ((unsigned int)(r + 1 - start) < len) && (r[1] == '\n')) /* \n\r\n */
{
if (((unsigned int)(r + 2 - start) < len) && (r[2] == '\r')) /* \n\r\n\r */
{
if (((unsigned int)(r + 3 - start) < len) && (r[3] == '\n'))
/* \n\r\n\r\n oh hey I'm gonna stop here before it gets too insane */
s = "\r\n";
else
s = "\n\r";
}
else
s = "\r\n";
}
else
s = "\n\r";
}
}
else
s = "\r";
}
else
s = "\n";
slen = strlen(s);
snprintf((char *)sep, sizeof(sep), "%s%s", s, s);
p = start;
line_len = r - p;
while (len && r)
{
unsigned char *ptr, *semi = p;
if (line_len > MAX_HEADER_SIZE)
{
WARN("Ignoring unreasonably large header starting with:\n %.32s\n", p);
goto skip_header;
}
semi += (line_len - _azy_events_valid_header_name((const char *)p, line_len));
if (semi == p) goto skip_header;
ptr = semi + 1;
while ((isspace(*ptr)) && (ptr - p < line_len))
ptr++;
if (_azy_events_valid_header_value((const char *)ptr, line_len - (ptr - p)))
{
const char *key, *value;
p[semi - p] = 0;
ptr[line_len - (ptr - p)] = 0;
key = (const char *)p;
value = (const char *)ptr;
INFO("Found header: key='%s'", key);
INFO("Found header: value='%s'", value);
azy_net_header_set(net, key, value);
if (!strcasecmp(key, "content-length"))
net->http.content_length = strtol((const char *)value, NULL, 10);
}
skip_header:
len -= line_len + slen;
if (len < slen)
break;
p = r + slen;
/* double separator: STOP */
if (!strncmp((char*)p, s, slen))
{
net->headers_read = EINA_TRUE;
break;
}
r = azy_memstr(p, (const unsigned char *)s, len, slen);
line_len = r - p;
/* FIXME: to be fully 1.1 compliant, lines without a colon
* be filtered and checked to see if is a continuing header
* from the previous line
*/
}
AZY_SKIP_BLANK(p);
if (!net->headers_read)
return EINA_TRUE;
if (!net->http.content_length) net->http.content_length = -1;
if (len)
{
int64_t rlen;
/* if we get here, we need to append to the buffers */
if (net->http.content_length > 0)
{
if (len > net->http.content_length)
{
rlen = net->http.content_length;
net->overflow_length = len - rlen;
WARN("Extra content length of %lli!", net->overflow_length);
net->overflow = malloc(net->overflow_length);
/* FIXME: uhhhh fuck? */
EINA_SAFETY_ON_NULL_RETURN_VAL(net->overflow, EINA_FALSE);
memcpy(net->overflow, p + rlen, net->overflow_length);
#ifdef ISCOMFITOR
if (azy_rpc_log_dom >= 0)
{
int64_t x;
RPC_INFO("OVERFLOW:\n<<<<<<<<<<<<<");
for (x = 0; x < net->overflow_length; x++)
putc(net->overflow[x], stdout);
fflush(stdout);
}
#endif
}
else
rlen = len;
}
else
/* this shouldn't be possible unless someone is violating spec */
rlen = len;
INFO("Set recv size to %lli (previous %lli)", rlen, prev_size);
net->size = rlen;
net->buffer = malloc(rlen);
/* FIXME: cleanup */
EINA_SAFETY_ON_NULL_RETURN_VAL(net->buffer, EINA_FALSE);
memcpy(net->buffer, p, rlen);
}
return EINA_TRUE;
}
