Exemplo n.º 1
0
cc_int32 ccs_callback_new (ccs_callback_t                  *out_callback,
			   cc_int32                         in_invalid_object_err,
			   ccs_pipe_t                       in_client_pipe,
			   ccs_pipe_t                       in_reply_pipe,
			   ccs_callback_owner_t             in_owner,
			   ccs_callback_owner_invalidate_t  in_owner_invalidate_function)
{
    cc_int32 err = ccNoError;
    ccs_callback_t callback = NULL;
    ccs_client_t client = NULL;
    
    if (!out_callback                   ) { err = cci_check_error (ccErrBadParam); }
    if (!ccs_pipe_valid (in_client_pipe)) { err = cci_check_error (ccErrBadParam); }
    if (!ccs_pipe_valid (in_reply_pipe) ) { err = cci_check_error (ccErrBadParam); }
    if (!in_owner                       ) { err = cci_check_error (ccErrBadParam); }
    if (!in_owner_invalidate_function   ) { err = cci_check_error (ccErrBadParam); }
    
    if (!err) {
        callback = malloc (sizeof (*callback));
        if (callback) { 
            *callback = ccs_callback_initializer;
        } else {
            err = cci_check_error (ccErrNoMem); 
        }
    }
    
    if (!err) {
        err = ccs_server_client_for_pipe (in_client_pipe, &client);
    }
    
    if (!err) {
	err = ccs_pipe_copy (&callback->client_pipe, in_client_pipe);
    }
    
    if (!err) {
	err = ccs_pipe_copy (&callback->reply_pipe, in_reply_pipe);
    }
    
    if (!err) {
        callback->client_pipe = in_client_pipe;
        callback->reply_pipe = in_reply_pipe;
        callback->invalid_object_err = in_invalid_object_err;
        callback->owner = in_owner;
        callback->owner_invalidate = in_owner_invalidate_function;
    
        err = ccs_client_add_callback (client, callback);
    }
     
    if (!err) {
        *out_callback = callback;
        callback = NULL;
    }
    
    ccs_callback_release (callback);
    
    return cci_check_error (err);    
}
Exemplo n.º 2
0
static cc_int32 ccs_list_iterator_new (ccs_list_iterator_t *out_list_iterator,
                                       ccs_list_t           io_list,
                                       ccs_pipe_t           in_client_pipe)
{
    cc_int32 err = ccNoError;
    ccs_list_iterator_t list_iterator = NULL;
    
    if (!out_list_iterator) { err = cci_check_error (ccErrBadParam); }
    if (!io_list          ) { err = cci_check_error (ccErrBadParam); }
    /* client_pipe may be NULL if the iterator exists for internal server use */
    
    if (!err) {
        list_iterator = malloc (sizeof (*list_iterator));
        if (list_iterator) { 
            *list_iterator = ccs_list_iterator_initializer;
        } else {
            err = cci_check_error (ccErrNoMem); 
        }
    }
    
    if (!err) {
        err = ccs_server_new_identifier (&list_iterator->identifier);
    }

    if (!err) {
        list_iterator->list = io_list;
        list_iterator->current = 0;
        
        err = cci_array_insert (io_list->iterators, 
                                (cci_array_object_t) list_iterator, 
				cci_array_count (io_list->iterators));
    }
    
    if (!err && ccs_pipe_valid (in_client_pipe)) {
        ccs_client_t client = NULL;
        
        err = ccs_pipe_copy (&list_iterator->client_pipe, in_client_pipe);
        
        if (!err) {
            err = ccs_server_client_for_pipe (in_client_pipe, &client);
        }
        
        if (!err) {
            err = ccs_client_add_iterator (client, list_iterator);
        }
    }

    if (!err) {
        *out_list_iterator = list_iterator;
        list_iterator = NULL;
    }
    
    ccs_list_iterator_release (list_iterator);
    
    return cci_check_error (err);    
}