static Pulse_Server_Info *
deserialize_server_info(Pulse *conn, Pulse_Tag *tag)
{
   Pulse_Server_Info *ev;
   pa_sample_spec spec;

   ev = calloc(1, sizeof(Pulse_Server_Info));
   ev->conn = conn;
   EINA_SAFETY_ON_NULL_RETURN_VAL(ev, NULL);
   EINA_SAFETY_ON_FALSE_GOTO(untag_string(tag, &ev->name), error);
   EINA_SAFETY_ON_FALSE_GOTO(untag_string(tag, &ev->version), error);
   EINA_SAFETY_ON_FALSE_GOTO(untag_string(tag, &ev->username), error);
   EINA_SAFETY_ON_FALSE_GOTO(untag_string(tag, &ev->hostname), error);
   EINA_SAFETY_ON_FALSE_GOTO(untag_sample(tag, &spec), error);
   EINA_SAFETY_ON_FALSE_GOTO(untag_string(tag, &ev->default_sink), error);
   EINA_SAFETY_ON_FALSE_GOTO(untag_string(tag, &ev->default_source), error);

   return ev;
error:
   pulse_server_info_free(ev);
   return NULL;
}
Beispiel #2
0
char *
escarg_utils_escape(Escaping_Function func,
                    const char *fmt,
                    va_list args)
{
   Eina_Strbuf *buf;
   const char *p, *pp;
   char *ret = NULL;
   size_t fmtlen;
   Eina_Bool r;

   buf = eina_strbuf_new();
   fmtlen = strlen(fmt);
   pp = strchr(fmt, '%');
   if (!pp) pp = fmt + fmtlen;
   for (p = fmt; p && *p; pp = strchr(p, '%'))
     {
        Eina_Bool l = EINA_FALSE;
        Eina_Bool ll = EINA_FALSE;
        long long int i;
        unsigned long long int u;
        double d;
        char *s,
             *esc;

        if (!pp) pp = fmt + fmtlen;
        if(pp - p)
           EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_length(buf, p, pp - p), err);
        if (*pp != '%') break;  /* no more fmt strings */

top:
        esc = NULL;

        switch (pp[1])
          {
           case 0:
             ERR("Invalid format string!");
             goto err;

           case 'l':
             if (!l)
               l = EINA_TRUE;
             else if (!ll)
               ll = EINA_TRUE;
             else
               {
                  ERR("Invalid format string!");
                  goto err;
               }
             pp++;
             goto top;

           case 'f':
             if (ll)
               {
                  ERR("Invalid format string!");
                  goto err;
               }
             d = va_arg(args, double);
             esc = func(ESCARG_TYPE_DOUBLE, &d);
             break;

           case 'i':
           case 'd':
             if (l && ll)
               {
                  i = va_arg(args, long long int);
                  esc = func(ESCARG_TYPE_LONG_LONG_INT, &i);
               }
             else if (l)
               {
                  i = va_arg(args, long int);
                  esc = func(ESCARG_TYPE_LONG_INT, &i);
               }
             else
               {
Beispiel #3
0
char *
esql_query_escape(Eina_Bool   backslashes,
                  size_t     *len,
                  const char *fmt,
                  va_list     args)
{
    Eina_Strbuf *buf;
    const char *p, *pp;
    char *ret = NULL;
    size_t fmtlen;

    buf = eina_strbuf_new();
    *len = 0;
    fmtlen = strlen(fmt);
    pp = strchr(fmt, '%');
    if (!pp) pp = fmt + fmtlen;
    for (p = fmt; p && *p; pp = strchr(p, '%'))
    {
        Eina_Bool l = EINA_FALSE;
        Eina_Bool ll = EINA_FALSE;
        long long int i;
        double d;
        char *s;

        if (!pp) pp = fmt + fmtlen;
        EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_length(buf, p, ((pp - p > 1) ? pp - p : 1)), err);
        if (*pp != '%') break;  /* no more fmt strings */
top:
        switch (pp[1])
        {
        case 0:
            ERR("Invalid format string!");
            goto err;

        case 'l':
            if (!l)
                l = EINA_TRUE;
            else if (!ll)
                ll = EINA_TRUE;
            else
            {
                ERR("Invalid format string!");
                goto err;
            }
            pp++;
            goto top;

        case 'f':
            if (l && ll)
            {
                ERR("Invalid format string!");
                goto err;
            }
            d = va_arg(args, double);
            EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_printf(buf, "%lf", d), err);
            break;

        case 'i':
        case 'd':
            if (l && ll)
                i = va_arg(args, long long int);
            else if (l)
                i = va_arg(args, long int);
            else
                i = va_arg(args, int);
            EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_printf(buf, "%lli", i), err);
            break;

        case 's':
            if (l)
            {
                ERR("Invalid format string!");
                goto err;
            }
            s = va_arg(args, char *);
            if (!s) break;
            s = esql_string_escape(backslashes, s);
            EINA_SAFETY_ON_NULL_GOTO(s, err);
            EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append(buf, s), err);
            free(s);
            break;

        case 'c':
            if (l)
            {
                ERR("Invalid format string!");
                goto err;
            }
            {
                char c[3];

                c[0] = va_arg(args, int);
                c[1] = c[2] = 0;
                s = esql_string_escape(backslashes, c);
                EINA_SAFETY_ON_NULL_GOTO(s, err);
                EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append(buf, s), err);
                free(s);
            }
            break;

        case '%':
            EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_char(buf, '%'), err);
            break;

        default:
            ERR("Unsupported format string: '%s'!", pp);
            goto err;
        }