Ejemplo n.º 1
0
globus_result_t
globus_xio_string_cntl_string_list(
    void *                              attr,
    const char *                        key,
    const char *                        val,
    int                                 cmd,
    globus_xio_driver_attr_cntl_t       cntl_func)
{
    int                                 i = 0;
    globus_list_t *                     val_list;
    globus_list_t *                     list;
    char **                             argv;
    int                                 argc;
    globus_result_t                     result;
    int                                 del;

    /* delimitor is the first character */
    if(val == NULL)
    {
        return GLOBUS_SUCCESS;
    }

    del = (int)*val;
    val++;

    val_list = globus_list_from_string(val, del, NULL);
    list = val_list;

    argc = globus_list_size(list);
    argv = (char **) calloc(argc+1, sizeof(char *));
    i = argc - 1;
    while(!globus_list_empty(list))
    {
        argv[i] = (char *)globus_list_first(list);
        list = globus_list_rest(list);
        i--;
    }

    result = globus_xio_string_cntl_bouncer(cntl_func, attr, cmd, argv);

    globus_list_destroy_all(val_list, globus_libc_free);
    globus_free(argv);
    
    return result;
}
Ejemplo n.º 2
0
static
void
globus_l_gss_read_test_cases(char * filename)
{
    int fd;
    int rc;
    struct stat st;
    char * buffer;
    char * line;
    compare_name_test_case_t * test_case;
    globus_list_t * rline_list = NULL;
    static char name_type1[32], name_type2[32];
    static char name_token1[128], name_token2[128];
    static char expectation[16];

    rc = stat(filename, &st);
    if (rc != 0)
    {
        perror("stat");
        exit(1);
    }

    buffer = malloc(st.st_size + 1);
    if (buffer == NULL)
    {
        perror("malloc");
        exit(1);
    }
    fd = open(filename, O_RDONLY, 0);
    if (fd < 0)
    {
        perror("open");
        exit(1);
    }

    rc = read(fd, buffer, st.st_size);
    if (rc != st.st_size)
    {
        perror("read");
        exit(1);
    }
    buffer[st.st_size] = '\0';

    /* reversed order list */
    rline_list = globus_list_from_string(buffer, '\n', " \t\r\n");

    while (! globus_list_empty(rline_list))
    {
        line = globus_list_remove(&rline_list, rline_list);

        if (strlen(line) != 0)
        {
            test_case = calloc(1, sizeof(compare_name_test_case_t));

            sscanf(line, "%[^,], %[^,], %[^,], %[^,], %[^,]",
                    name_type1, name_token1,
                    name_type2, name_token2,
                    expectation);

            test_case->test_name = strdup(line);

            compare_l_parse_name_type(
                    name_type1, name_token1,
                    &test_case->name_type1, &test_case->name_token1);
            compare_l_parse_name_type(
                    name_type2, name_token2,
                    &test_case->name_type2, &test_case->name_token2);
            if (strcmp(expectation, "GLOBUS_TRUE") == 0)
            {
                test_case->expectation = GLOBUS_TRUE;
            }
            else if (strcmp(expectation, "GLOBUS_FALSE") == 0)
            {
                test_case->expectation = GLOBUS_FALSE;
            }
            else
            {
                globus_assert((strcmp(expectation, "GLOBUS_FALSE") == 0) ||
                              (strcmp(expectation, "GLOBUS_FALSE") == 0));
            }
            globus_list_insert(&test_cases, test_case);
        }
        free(line);
    }
    free(buffer);
}
Ejemplo n.º 3
0
/* STRING PARSING ATTR SETTING */
globus_result_t
globus_i_xio_string_cntl_parser(
    const char *                        env_str,
    globus_xio_string_cntl_table_t *    table,
    void *                              attr,
    globus_xio_driver_attr_cntl_t       cntl_func)
{
    int                                 i;
    char *                              key;
    char *                              val;
    char *                              tmp_s;
    globus_list_t *                     list;
    globus_object_t *                   error = NULL;
    globus_result_t                     res = GLOBUS_SUCCESS;
    GlobusXIOName(globus_i_xio_string_cntl_parser);
    
    list = globus_list_from_string(env_str, ';', NULL);

    while(!globus_list_empty(list))
    {
        key = (char *) globus_list_remove(&list, list);

        tmp_s = strchr(key, '=');
        if(tmp_s != NULL)
        {
            *tmp_s = '\0';
            val = tmp_s + 1;

            for(i = 0; table[i].key != NULL; i++)
            {
                /* if we have a match */
                if(strcmp(table[i].key, key) == 0)
                {
                    res = table[i].parse_func(
                        attr, key, val, table[i].cmd, cntl_func);
                    if(res != GLOBUS_SUCCESS)
                    {
                        /* restore '=' */
                        *tmp_s = '=';
                        res = GlobusXIOErrorWrapFailedWithMessage(
                            res, "String cntl '%s' failed", key);
                    }
                    
                    break;
                }
            }
            
            if(!table[i].key)
            {
                res = GlobusXIOErrorParameter(key);
            }
        }
        else
        {
            res = GlobusXIOErrorParameter(key);
        }
        
        if(res != GLOBUS_SUCCESS)
        {
            if(!error)
            {
                error = globus_error_construct_multiple(
                    GLOBUS_XIO_MODULE,
                    GLOBUS_XIO_ERROR_PARAMETER,
                    "One or more of the string cntls failed");
            }
            
            globus_error_mutliple_add_chain(
                error, globus_error_get(res), NULL);
        }
        
        globus_free(key);
    }
    
    return globus_error_put(error);
}
static
globus_result_t
globus_l_xio_net_manager_attr_set_string_options(
    globus_l_xio_net_manager_attr_t    *attr,
    const char                         *options_string)
{
    globus_result_t                     result = GLOBUS_SUCCESS;
    globus_list_t                      *options = NULL;
    globus_list_t                      *rev_options;
    int                                 num_options;
    globus_net_manager_attr_t          *new_attrs;
    globus_net_manager_context_t        new_context = NULL;
    char                               *scope = NULL;
    char                               *new_task_id = NULL;
    size_t                              attrnum = 0;

    rev_options = globus_list_from_string(options_string, ';', NULL);
    /* dislike that this func produces a reversed list */
    while (!globus_list_empty(rev_options))
    {
        globus_list_insert(
            &options, globus_list_remove(&rev_options, rev_options));
    }

    num_options = globus_list_size(options);

    if (num_options == 0)
    {
        goto no_options;
    }
    new_attrs = calloc(num_options+1, sizeof(globus_net_manager_attr_t));
    if (!new_attrs)
    {
        result = GlobusNetManagerErrorMemory("attr_array");
        goto new_attrs_calloc_fail;
    }
    while (!globus_list_empty(options))
    {
        char                           *opt, *val;

        opt = globus_list_remove(&options, options);
        if (*opt == '\0')
        {
            free(opt);
            continue;
        }
        val = strchr(opt, '=');
        if (!val)
        {
            result = GlobusNetManagerErrorParameter("Invalid option string.");
            free(opt);
            goto no_equals;
        }
        *val++ = '\0';

        if (strcmp(opt, "manager") == 0)
        {
            result = globus_net_manager_attr_init(
                    &new_attrs[attrnum++],
                    "net_manager",
                    opt,
                    val);
            if (result)
            {
                free(opt);
                new_attrs[attrnum-1] = globus_net_manager_null_attr;
                goto new_attr_init_fail;
            }
            free(scope);
            scope = strdup(val);
            if (!scope)
            {
                result = GlobusNetManagerErrorMemory("scope");
                free(opt);
                new_attrs[attrnum++] = globus_net_manager_null_attr;
                goto strdup_scope_fail;
            }
        }
        else if (strcmp(opt, "task-id") == 0)
        {
            free(new_task_id);
            new_task_id = strdup(val);
            if (!new_task_id)
            {
                result = GlobusNetManagerErrorMemory("task-id");
                free(opt);
                new_attrs[attrnum++] = globus_net_manager_null_attr;
                goto strdup_task_id_fail;
            }
        }
        else
        {
            result = globus_net_manager_attr_init(
                    &new_attrs[attrnum++],
                    scope ? scope : "global",
                    opt,
                    val);
            if (result)
            {
                free(opt);
                new_attrs[attrnum-1] = globus_net_manager_null_attr;
                goto new_attr_init_fail;
            }
        }
        free(opt);
    }
    new_attrs[attrnum++] = globus_net_manager_null_attr;
    if (new_attrs)
    {
        result = globus_net_manager_context_init(
            &new_context,
            new_attrs);
        if (result)
        {
            goto new_context_fail;
        }
        globus_net_manager_context_destroy(attr->context);
        attr->context = new_context;
    }

    if (new_task_id)
    {
        free(attr->task_id);
        attr->task_id = new_task_id;
        new_task_id = NULL;
    }
    if (new_attrs)
    {
        globus_net_manager_attr_array_delete(attr->attr_array);
        attr->attr_array = new_attrs;
        new_attrs = NULL;
    }

new_context_fail:
new_attr_init_fail:
strdup_task_id_fail:
strdup_scope_fail:
no_equals:
    free(new_task_id);
    free(scope);
    globus_net_manager_attr_array_delete(new_attrs);
new_attrs_calloc_fail:
    globus_list_destroy_all(options, free);
no_options:
    return result;
}