/* * Called when the LFS module is activated. * Need to initialize APR ourselves */ int lfs_activate(void) { globus_extension_registry_add( GLOBUS_GFS_DSI_REGISTRY, "lfs", GlobusExtensionMyModule(globus_gridftp_server_lfs), &globus_l_gfs_lfs_dsi_iface); // See if we're configured to write to statsd char * local_host = globus_malloc(256); if (local_host) { memset(local_host, 0, 256); if (gethostname(local_host, 255)) { strcpy(local_host, "UNKNOWN"); } } char statsd_namespace_prefix [] = "lfs.gridftp."; char * statsd_namespace = globus_malloc(strlen(statsd_namespace_prefix)+ strlen(local_host)+1); strcpy(statsd_namespace, statsd_namespace_prefix); char * source = local_host; char * dest; for (dest = statsd_namespace + strlen(statsd_namespace_prefix); *source != '\0'; ++source, ++dest) { if (*source == '.') { *dest = '_'; } else { *dest = *source; } } *dest = '\0'; char * lfs_statsd_link_port = getenv("GRIDFTP_LFS_STATSD_PORT"); char * lfs_statsd_link_host = getenv("GRIDFTP_LFS_STATSD_HOST"); if (lfs_statsd_link_host) { int lfs_statsd_link_port_conv = 8125; if (lfs_statsd_link_port) { lfs_statsd_link_port_conv = atoi(lfs_statsd_link_port); } lfs_statsd_link = statsd_init_with_namespace(lfs_statsd_link_host, lfs_statsd_link_port_conv, statsd_namespace); globus_gfs_log_message(GLOBUS_GFS_LOG_INFO, "Sending log data to statsd %s:%i, namespace %s\n", lfs_statsd_link_host, lfs_statsd_link_port_conv, statsd_namespace); } else { globus_gfs_log_message(GLOBUS_GFS_LOG_INFO, "Not logging to statsd. Set $GRIDFTP_LFS_STATSD_HOST to enable\n"); lfs_statsd_link = NULL; } globus_free(statsd_namespace); globus_gfs_log_message(GLOBUS_GFS_LOG_INFO, "LFS DSI activated.\n"); STATSD_COUNT("activate",1); if (local_host) globus_free(local_host); return 0; }
static globus_ftp_client_plugin_t * restart_marker_plugin_copy_cb( globus_ftp_client_plugin_t * plugin_template, void * plugin_specific) { restart_marker_plugin_info_t * old_ps; globus_ftp_client_plugin_t * new_plugin; globus_result_t result; old_ps = (restart_marker_plugin_info_t *) plugin_specific; new_plugin = (globus_ftp_client_plugin_t *) globus_malloc(sizeof(globus_ftp_client_plugin_t)); if(new_plugin == GLOBUS_NULL) { return GLOBUS_NULL; } result = globus_ftp_client_restart_marker_plugin_init( new_plugin, old_ps->begin_cb, old_ps->marker_cb, old_ps->complete_cb, old_ps->user_arg); if(result != GLOBUS_SUCCESS) { globus_free(new_plugin); new_plugin = GLOBUS_NULL; } return new_plugin; }
static globus_result_t globus_l_xio_pipe_attr_init( void ** out_attr) { xio_l_pipe_attr_t * attr; globus_result_t result; GlobusXIOName(globus_l_xio_pipe_attr_init); GlobusXIOPipeDebugEnter(); /* * create a file attr structure and intialize its values */ attr = (xio_l_pipe_attr_t *) globus_malloc(sizeof(xio_l_pipe_attr_t)); if(!attr) { result = GlobusXIOErrorMemory("attr"); goto error_attr; } memcpy(attr, &xio_l_pipe_attr_default, sizeof(xio_l_pipe_attr_t)); *out_attr = attr; GlobusXIOPipeDebugExit(); return GLOBUS_SUCCESS; error_attr: GlobusXIOPipeDebugExitWithError(); return result; }
static globus_error_base_instance_t * s_base_instance_data (globus_object_t * error) { void * instance_data_vp; globus_object_t * base; globus_error_base_instance_t * instance_data; base = globus_object_upcast (error, GLOBUS_ERROR_TYPE_BASE); instance_data_vp = globus_object_get_local_instance_data (base); instance_data = (globus_error_base_instance_t *) instance_data_vp; if ( instance_data != NULL ) { return instance_data; } else { instance_data = globus_malloc (sizeof(globus_error_base_instance_t)); if (instance_data != NULL) { instance_data->source_module = NULL; instance_data->causal_error = NULL; globus_object_set_local_instance_data (base, (void *) instance_data); } return instance_data; } }
static void s_base_instance_copy (void * instance_datavp, void ** copyvp) { globus_error_base_instance_t * instance_data; globus_error_base_instance_t * copy; instance_data = ((globus_error_base_instance_t *) instance_datavp); if (copyvp!=NULL) { if (instance_datavp==NULL) { (*copyvp) = (void *) NULL; return; } copy = globus_malloc (sizeof(globus_error_base_instance_t)); if (copy!=NULL) { if (instance_data!=NULL) { copy->source_module = instance_data->source_module; copy->causal_error = globus_object_copy(instance_data->causal_error); } } (*copyvp) = (void *) copy; } }
/****************************************************************************** Function: globus_l_gass_server_ez_tilde_expand() Description: Parameters: Returns: ******************************************************************************/ static int globus_l_gass_server_ez_tilde_expand(unsigned long options, char *inpath, char **outpath) { #ifndef TARGET_ARCH_WIN32 /* * If this is a relative path, the strip off the leading /./ */ if(strlen(inpath) >= 2U) { if (inpath[1] == '.' && inpath[2] == '/') { inpath += 3; goto notilde; } } /* here call the new function globus_tilde_expand()*/ return globus_tilde_expand(options, GLOBUS_TRUE, /* url form /~[user][/etc]*/ inpath, outpath); #endif /* TARGET_ARCH_WIN32*/ notilde: *outpath = globus_malloc(strlen(inpath)+1); strcpy(*outpath, inpath); return GLOBUS_SUCCESS; } /* globus_l_gass_server_ez_tilde_expand() */
globus_fifo_t * globus_fifo_copy ( const globus_fifo_t * fifo) { globus_fifo_t * copy; struct globus_fifo_s * s_copy; struct globus_fifo_s * s_fifo; if (fifo == GLOBUS_NULL) return NULL; s_fifo = *fifo; if(s_fifo==GLOBUS_NULL) return NULL; copy = globus_malloc (sizeof(globus_fifo_t)); if (copy == NULL) return NULL; globus_fifo_init(copy); s_copy = *copy; s_copy->head = globus_list_copy(s_fifo->head); s_copy->tail = s_copy->head; while(!globus_list_empty(globus_list_rest(s_copy->tail))) { s_copy->tail = globus_list_rest (s_copy->tail); } s_copy->size = s_fifo->size; return copy; }
static void globus_l_error_ftp_copy( void * src, void ** dst) { globus_l_error_ftp_data_t * copy; globus_l_error_ftp_data_t * source; if(src && dst) { copy = (globus_l_error_ftp_data_t *) globus_malloc(sizeof(globus_l_error_ftp_data_t)); if(copy) { source = (globus_l_error_ftp_data_t *) src; copy->code = source->code; copy->message = source->message ? globus_libc_strdup(source->message) : NULL; } *dst = copy; } }
/************************************************************************ * stack functions ***********************************************************************/ globus_result_t globus_xio_stack_init( globus_xio_stack_t * stack, globus_xio_attr_t stack_attr) { globus_i_xio_stack_t * xio_stack; GlobusXIOName(globus_xio_stack_init); GlobusXIODebugEnter(); if(stack == NULL) { GlobusXIODebugExitWithError(); return GlobusXIOErrorParameter("stack"); } xio_stack = globus_malloc(sizeof(globus_i_xio_stack_t)); memset(xio_stack, '\0', sizeof(globus_i_xio_stack_t)); *stack = xio_stack; GlobusXIODebugExit(); return GLOBUS_SUCCESS; }
/* * copy an attribute structure */ static globus_result_t globus_l_xio_pipe_attr_copy( void ** dst, void * src) { xio_l_pipe_attr_t * attr; xio_l_pipe_attr_t * src_attr; globus_result_t result; GlobusXIOName(globus_l_xio_pipe_attr_copy); GlobusXIOPipeDebugEnter(); src_attr = (xio_l_pipe_attr_t *) src; attr = (xio_l_pipe_attr_t *) globus_malloc(sizeof(xio_l_pipe_attr_t)); if(!attr) { result = GlobusXIOErrorMemory("attr"); goto error_attr; } memcpy(attr, src_attr, sizeof(xio_l_pipe_attr_t)); *dst = attr; GlobusXIOPipeDebugExit(); return GLOBUS_SUCCESS; error_attr: GlobusXIOPipeDebugExitWithError(); return result; }
globus_result_t globus_i_xio_win32_complete( globus_callback_func_t callback, void * user_arg) { globus_l_xio_win32_poll_entry_t * entry; globus_result_t result; GlobusXIOName(globus_i_xio_win32_complete); GlobusXIOSystemDebugEnter(); if (! globus_i_am_only_thread()) { return globus_callback_register_oneshot( 0, 0, callback, user_arg); } win32_mutex_lock(&globus_l_xio_win32_poll_lock); { if(globus_l_xio_win32_poll_free) { entry = globus_l_xio_win32_poll_free; globus_l_xio_win32_poll_free = entry->next; } else { entry = (globus_l_xio_win32_poll_entry_t *) globus_malloc(sizeof(globus_l_xio_win32_poll_entry_t)); if(!entry) { result = GlobusXIOErrorMemory("entry"); goto error_malloc; } } entry->callback = callback; entry->user_arg = user_arg; GlobusLWin32PollQueueEnqueue(entry); if(globus_l_xio_win32_poll_event_sleeping && !globus_l_xio_win32_poll_event_pending) { SetEvent(globus_l_xio_win32_poll_event); globus_l_xio_win32_poll_event_pending = GLOBUS_TRUE; } } win32_mutex_unlock(&globus_l_xio_win32_poll_lock); GlobusXIOSystemDebugExit(); return GLOBUS_SUCCESS; error_malloc: return result; }
static char * globus_l_error_ftp_printable( globus_object_t * error) { globus_l_error_ftp_data_t * data; char * error_string; char buf[4]; char * message; int message_len; if(!error) { return NULL; } data = (globus_l_error_ftp_data_t *) globus_object_get_local_instance_data(error); message = data->message; if(message) { message_len = strlen(message); if(message_len > 3 && message[3] == ' ') { buf[0] = message[0]; buf[1] = message[1]; buf[2] = message[2]; buf[3] = '\0'; if(data->code == atoi(buf)) { message += 4; message_len -= 4; } } } else { message_len = 0; } error_string = globus_malloc(sizeof(char) * (15 + message_len)); if(error_string) { sprintf( error_string, "%d %s", data->code, message ? message : ""); } return error_string; }
/* * copy an attribute structure */ static globus_result_t globus_l_xio_popen_attr_copy( void ** dst, void * src) { xio_l_popen_attr_t * attr; xio_l_popen_attr_t * src_attr; globus_result_t result; int i; GlobusXIOName(globus_l_xio_popen_attr_copy); GlobusXIOPOpenDebugEnter(); src_attr = (xio_l_popen_attr_t *) src; attr = (xio_l_popen_attr_t *) globus_malloc(sizeof(xio_l_popen_attr_t)); if(!attr) { result = GlobusXIOErrorMemory("attr"); goto error_attr; } memcpy(attr, src_attr, sizeof(xio_l_popen_attr_t)); if(src_attr->program_name != NULL) { attr->program_name = strdup(src_attr->program_name); } if(src_attr->argc > 0) { attr->argv = (char **)globus_calloc(attr->argc+1, sizeof(char*)); for(i = 0; i < attr->argc; i++) { attr->argv[i] = strdup(src_attr->argv[i]); } attr->argv[i] = NULL; } if(src_attr->env_count > 0) { attr->env = (char **)globus_calloc(attr->env_count+1, sizeof(char*)); for(i = 0; i < attr->env_count; i++) { attr->env[i] = strdup(src_attr->env[i]); } attr->env[i] = NULL; } *dst = attr; GlobusXIOPOpenDebugExit(); return GLOBUS_SUCCESS; error_attr: GlobusXIOPOpenDebugExitWithError(); return result; }
globus_result_t globus_l_xio_bounce_open( const globus_xio_contact_t * contact_info, void * driver_link, void * driver_attr, globus_xio_operation_t op) { bounce_info_t * info; globus_result_t res; GlobusXIOName(globus_l_xio_bounce_open); GlobusXIOTestDebugInternalEnter(); info = (bounce_info_t *) globus_malloc(sizeof(bounce_info_t)); memset(info, '\0', sizeof(bounce_info_t)); info->next_op = TEST_READ; info->bounce_count = 0; info->max_count = MAX_COUNT; info->start_op = TEST_OPEN; info->handle = (bounce_handle_t *) globus_malloc(sizeof(bounce_handle_t)); globus_mutex_init(&info->handle->mutex, NULL); info->handle->closed_iface = GLOBUS_FALSE; info->handle->closed_cb = GLOBUS_FALSE; info->handle->open_cb = GLOBUS_FALSE; res = globus_xio_driver_pass_open( op, contact_info, open_bounce_cb, (void*)info); if(res != GLOBUS_SUCCESS) { bounce_handle_destroy(info->handle); globus_free(info); goto err; } GlobusXIOTestDebugInternalExit(); return GLOBUS_SUCCESS; err: GlobusXIOTestDebugInternalExitWithError(); return res; }
int globus_extension_register_builtin( const char * extension_name, globus_module_descriptor_t * module_descriptor) { globus_l_extension_builtin_t * builtin; GlobusFuncName(globus_extension_register_builtin); GlobusExtensionDebugEnterSymbol(extension_name); builtin = (globus_l_extension_builtin_t *) globus_malloc(sizeof(globus_l_extension_builtin_t)); if(!builtin) { goto error_alloc; } builtin->owner = (globus_l_extension_module_t *) globus_thread_getspecific(globus_l_extension_owner_key); builtin->module = module_descriptor; builtin->extension_name = globus_libc_strdup(extension_name); if(!builtin->extension_name) { goto error_strdup; } globus_rmutex_lock(&globus_l_extension_mutex); { int rc; rc = globus_hashtable_insert( &globus_l_extension_builtins, builtin->extension_name, builtin); if(rc != 0) { goto error_insert; } } globus_rmutex_unlock(&globus_l_extension_mutex); GlobusExtensionDebugExit(); return GLOBUS_SUCCESS; error_insert: globus_rmutex_unlock(&globus_l_extension_mutex); globus_free(builtin->extension_name); error_strdup: globus_free(builtin); error_alloc: GlobusExtensionDebugExitWithError(); return GLOBUS_FAILURE; }
globus_result_t globus_gridftp_server_control_attr_copy( globus_gridftp_server_control_attr_t * dst, globus_gridftp_server_control_attr_t src) { globus_result_t res; globus_i_gsc_attr_t * attr; GlobusGridFTPServerName(globus_gridftp_server_control_attr_copy); if(dst == NULL) { res = GlobusGridFTPServerErrorParameter("dst"); goto err; } if(src == NULL) { res = GlobusGridFTPServerErrorParameter("src"); goto err; } if(src->version_ctl != GLOBUS_GRIDFTP_VERSION_CTL) { res = GlobusGridFTPServerErrorParameter("in_attr"); goto err; } attr = (globus_i_gsc_attr_t *) globus_malloc( sizeof(globus_i_gsc_attr_t)); if(attr == NULL) { res = GlobusGridFTPServerControlErrorSytem(); goto err; } attr->version_ctl = src->version_ctl; attr->funcs.resource_cb = src->funcs.resource_cb; globus_hashtable_copy( &attr->funcs.send_cb_table, &src->funcs.send_cb_table, NULL); globus_hashtable_copy( &attr->funcs.recv_cb_table, &src->funcs.recv_cb_table, NULL); attr->modes = globus_libc_strdup(src->modes); attr->types = globus_libc_strdup(src->types); *dst = attr; return GLOBUS_SUCCESS; err: GlobusGridFTPServerDebugExitWithError(); return res; }
void globus_i_gass_transfer_keyvalue_insert( globus_list_t ** list, char * key, char * value) { globus_gass_transfer_keyvalue_t * kv; kv = globus_malloc(sizeof(globus_gass_transfer_keyvalue_t)); kv->key = key; kv->value = value; globus_list_insert(list, kv); }
l_smtp_info_t * l_smtp_create_new_info() { l_smtp_info_t * info; info = (l_smtp_info_t *) globus_malloc(sizeof(l_smtp_info_t)); info->state = SMTP_HELO; info->read_offset = 0; info->buf_len = 1024; info->iovec.iov_base = info->message; info->iovec.iov_len = info->buf_len; sprintf(info->return_address, "%s", globus_l_return_address); return info; }
int globus_fifo_init (globus_fifo_t * fifo) { struct globus_fifo_s * s_fifo; if (fifo==GLOBUS_NULL) return -1; s_fifo = (struct globus_fifo_s *)globus_malloc(sizeof(struct globus_fifo_s)); *fifo = s_fifo; s_fifo->head = GLOBUS_NULL; s_fifo->tail = GLOBUS_NULL; s_fifo->size = 0; return 0; }
static globus_result_t globus_l_xio_bounce_close( void * driver_handle, void * attr, globus_xio_operation_t op) { bounce_info_t * info; globus_result_t res; GlobusXIOName(globus_l_xio_bounce_close); GlobusXIOTestDebugInternalEnter(); info = (bounce_info_t *) globus_malloc(sizeof(bounce_info_t)); memset(info, '\0', sizeof(bounce_info_t)); info->next_op = TEST_READ; info->bounce_count = 0; info->max_count = MAX_COUNT; info->start_op = TEST_CLOSE; info->wait_for = 1024; info->iovec = &info->tmp_iovec; info->iovec->iov_base = (globus_byte_t *)0x100; info->iovec->iov_len = 1024; info->iovec_count = 1; info->handle = driver_handle; /* verify close isn't called twice */ globus_assert(info->handle->closed_iface == GLOBUS_FALSE); info->handle->closed_iface = GLOBUS_TRUE; res = test_bounce_next_op(info, op); if(res != GLOBUS_SUCCESS) { bounce_handle_destroy(info->handle); goto err; } GlobusXIOTestDebugInternalExit(); return GLOBUS_SUCCESS; err: GlobusXIOTestDebugInternalExitWithError(); return res; }
static globus_result_t globus_l_xio_bounce_write( void * driver_handle, const globus_xio_iovec_t * iovec, int iovec_count, globus_xio_operation_t op) { bounce_info_t * info; globus_result_t res = GLOBUS_SUCCESS; globus_size_t wait_for; GlobusXIOName(globus_l_xio_bounce_write); GlobusXIOTestDebugInternalEnter(); wait_for = globus_xio_operation_get_wait_for(op); info = (bounce_info_t *) globus_malloc(sizeof(bounce_info_t)); memset(info, '\0', sizeof(bounce_info_t)); info->next_op = TEST_WRITE; info->bounce_count = 0; info->max_count = MAX_COUNT; info->start_op = TEST_WRITE; info->wait_for = wait_for; info->iovec = (globus_xio_iovec_t *)iovec; info->iovec_count = iovec_count; info->nbytes = 0; info->handle = driver_handle; res = test_bounce_next_op(info, op); if(res != GLOBUS_SUCCESS) { goto err; } GlobusXIOTestDebugInternalExit(); return GLOBUS_SUCCESS; err: GlobusXIOTestDebugInternalExitWithError(); return res; }
/** * Extract referral information from a request handle. * @ingroup globus_gass_transfer_request * * This function queries the request handle to determine any referral * information that it contains. This function should only be called * on request handles in the GLOBUS_GASS_TRANSFER_REQUEST_REFERRED * state. If no referral information is stored in the request handle, * then the referral will be initialized to an empty referral. * The referral must be destroyed by calling * globus_gass_transfer_referral_destroy() by the caller. * * @param request * The request handle to query. * @param referral * A pointer to an uninitialized referral structure. It will be * populated by calling this function. * * @retval GLOBUS_SUCCESS * The referral was successfully extracted from the request * handle. * @retval GLOBUS_GASS_TRANSFER_ERROR_NULL_POINTER * The referral pointer was GLOBUS_NULL; */ int globus_gass_transfer_request_get_referral( globus_gass_transfer_request_t request, globus_gass_transfer_referral_t * referral) { globus_gass_transfer_request_struct_t * req; /* Sanity check of arguments */ if(referral == GLOBUS_NULL) { return GLOBUS_GASS_TRANSFER_ERROR_NULL_POINTER; } /* Check for illegal handle */ req = globus_handle_table_lookup(&globus_i_gass_transfer_request_handles, request); if(req == GLOBUS_NULL) { return GLOBUS_GASS_TRANSFER_ERROR_INVALID_USE; } else if(req->referral_count == 0) { referral->url = GLOBUS_NULL; referral->count = 0; return GLOBUS_SUCCESS; } else { globus_size_t i; referral->url = globus_malloc(sizeof(char *) * req->referral_count); for(i = 0; i < req->referral_count; i++) { referral->url[i] = globus_libc_strdup(req->referral_url[i]); } referral->count = req->referral_count; return GLOBUS_SUCCESS; } }
static char * s_string_copy (char * string) { char * ns; int i, l; if ( string == NULL ) return NULL; l = strlen (string); ns = globus_malloc (sizeof(char *) * (l + 1)); if ( ns == NULL ) return NULL; for (i=0; i<l; i++) { ns[i] = string[i]; } ns[l] = '\00'; return ns; }
/** * Copy the instance data of a Globus GSSAPI Error object. * @ingroup globus_gssapi_error_object * * @param src * The source instance data * @param dst * The destination instance data * @return * void */ static void globus_l_error_copy_gssapi( void * src, void ** dst) { globus_l_gssapi_error_data_t * copy; globus_l_gssapi_error_data_t * data; if(src == NULL || dst == NULL) return; data = (globus_l_gssapi_error_data_t *) src; copy = (globus_l_gssapi_error_data_t *) globus_malloc(sizeof(globus_l_gssapi_error_data_t)); if(copy) { copy->major_status = data->major_status; copy->minor_status = data->minor_status; copy->is_globus_gsi = data->is_globus_gsi; } *dst = copy; }/* globus_l_error_copy_gssapi */
/* * globus_l_module_increment() */ static globus_bool_t globus_l_module_increment( globus_module_descriptor_t * module_descriptor, globus_l_module_key_t parent_key, globus_module_deactivate_proxy_cb_t deactivate_cb, void * user_arg) { globus_l_module_entry_t * entry; entry = globus_hashtable_lookup( &globus_l_module_table, (void *) module_descriptor->activation_func); if (entry != GLOBUS_NULL) { /* * The module has already been registered. Increment its reference * counter and add any new clients to the dependency list */ entry->reference_count++; if (parent_key != GLOBUS_NULL && globus_list_search(entry->clients, (void *) parent_key) == GLOBUS_NULL) { globus_list_insert(&entry->clients, (void *) parent_key); } if(entry->reference_count == 1) { entry->deactivate_cb = deactivate_cb; entry->user_arg = user_arg; return GLOBUS_TRUE; } else { return GLOBUS_FALSE; } } else { /* * This is the first time this module has been registered. Create a * new entry in the modules table. */ entry = (globus_l_module_entry_t *) globus_malloc(sizeof(globus_l_module_entry_t)); globus_assert(entry != GLOBUS_NULL); entry->descriptor = module_descriptor; entry->reference_count = 1; entry->clients = GLOBUS_NULL; entry->deactivate_cb = deactivate_cb; entry->user_arg = user_arg; if (parent_key != GLOBUS_NULL) { globus_list_insert(&entry->clients, (void *) parent_key); } globus_hashtable_insert( &globus_l_module_table, (void *) module_descriptor->activation_func, entry); globus_list_insert(&globus_l_module_list, entry); return GLOBUS_TRUE; } }
int main( int argc, char * argv[]) { int rc; globus_bool_t server = GLOBUS_FALSE; char gets_buffer[1024]; http_test_info_t * info; performance_t perf; info = (http_test_info_t *) globus_malloc(sizeof(http_test_info_t)); info->version = GLOBUS_XIO_HTTP_VERSION_UNSET; info->transfer_encoding = NULL; info->iterations = 100; info->temp_iterations = 100; info->size = 0; info->contact = NULL; while ((rc = getopt(argc, argv, "h:cst:b:v:i:")) != EOF) { switch (rc) { case 'h': usage(argv[0]); exit(0); case 'c': server = GLOBUS_FALSE; info->contact = fgets(gets_buffer, sizeof(gets_buffer), stdin); break; case 's': server = GLOBUS_TRUE; info->contact = NULL; break; case 't': if ((strcmp(optarg, CHUNKED) == 0) || (strcmp(optarg, IDENTITY) == 0)) { info->transfer_encoding = optarg; } else { usage(argv[0]); exit(1); } break; case 'b': sscanf(optarg, "%zd", &info->size); if (rc != 1) { usage(argv[0]); exit(1); } break; case 'v': if (strcmp(optarg, HTTP_1_0) == 0) { info->version = GLOBUS_XIO_HTTP_VERSION_1_0; } else if (strcmp(optarg, HTTP_1_1) == 0) { info->version = GLOBUS_XIO_HTTP_VERSION_1_1; } else { usage(argv[0]); exit(1); } break; case 'i': info->iterations = atoi(optarg); if (info->iterations <= 0) { usage(argv[0]); exit(1); } info->temp_iterations = info->iterations; break; default: usage(argv[0]); exit(1); } } if ((!server) && (info->contact == NULL)) { usage(argv[0]); exit(1); } if (info->iterations > 1 && info->version == GLOBUS_XIO_HTTP_VERSION_1_0) { fprintf(stderr, "Can't have multiple iterations with HTTP/1.0 server\n"); usage(argv[0]); exit(1); } rc = http_test_initialize( &info->tcp_driver, &info->http_driver, &info->stack); if (rc != 0) { goto error_exit; } if (server) { performance_init( &perf, server_test, throughput_next_size, info->iterations, "throughput-globus-xio-http", info->size); performance_start_slave(&perf, info); } else { performance_init( &perf, client_test, throughput_next_size, info->iterations, "throughput-globus-xio-http", info->size); rc = performance_start_master(&perf, info); if (rc != 0) { goto error_exit; } performance_write_timers(&perf); } globus_xio_stack_destroy(info->stack); globus_xio_driver_unload(info->tcp_driver); globus_xio_driver_unload(info->http_driver); globus_module_deactivate_all(); error_exit: if (rc == 0) { printf("Success\n"); } else { printf("Error\n"); } return rc; }
static globus_result_t globus_l_xio_telnet_open( const globus_xio_contact_t * contact_info, void * driver_link, void * driver_attr, globus_xio_operation_t op) { globus_result_t res; globus_l_xio_telnet_attr_t * attr; globus_l_xio_telnet_handle_t * handle; GlobusXIOName(globus_l_xio_telnet_open); /* decide what attr to use */ if(driver_attr != NULL) { attr = (globus_l_xio_telnet_attr_t *) driver_attr; } else if(driver_link != NULL) { attr = (globus_l_xio_telnet_attr_t *) driver_link; } else { /* default */ attr = NULL; } handle = (globus_l_xio_telnet_handle_t *) globus_calloc( sizeof(globus_l_xio_telnet_handle_t), 1); if(handle == NULL) { res = GlobusXIOErrorMemory("handle"); goto error_handle_alloc; } if(attr != NULL && attr->force_server) { handle->client = GLOBUS_FALSE; } else { handle->client = driver_link ? GLOBUS_FALSE : GLOBUS_TRUE; } handle->read_buffer_length = GLOBUS_L_XIO_TELNET_DEFAULT_BUFFER_SIZE; handle->read_buffer = globus_malloc(handle->read_buffer_length); if(handle->read_buffer == NULL) { res = GlobusXIOErrorMemory("buffer"); goto error_buffer_alloc; } globus_mutex_init(&handle->mutex, NULL); globus_fifo_init(&handle->write_q); handle->create_buffer_mode = attr ? attr->create_buffer_mode : GLOBUS_FALSE; res = globus_xio_driver_pass_open( op, contact_info, globus_l_xio_telnet_open_cb, handle); if(res != GLOBUS_SUCCESS) { goto error_pass; } return GLOBUS_SUCCESS; error_pass: globus_free(handle->read_buffer); globus_mutex_destroy(&handle->mutex); globus_fifo_destroy(&handle->write_q); error_buffer_alloc: globus_free(handle); error_handle_alloc: return res; }
static void globus_l_xio_telnet_request_data( globus_l_xio_telnet_handle_t * handle, globus_xio_operation_t op) { globus_bool_t complete; globus_size_t end; globus_size_t len; globus_result_t res = GLOBUS_SUCCESS; globus_size_t remainder; globus_size_t diff; if(!globus_fifo_empty(&handle->write_q)) { handle->write_iovec.iov_base = globus_fifo_dequeue(&handle->write_q); handle->write_iovec.iov_len = 3; res = globus_xio_driver_pass_write( op, &handle->write_iovec, 1, 3, globus_l_xio_telnet_cmd_write_cb, handle); if(res != GLOBUS_SUCCESS) { goto err; } return; } /* is there a full command in there, updates read_buffer_ndx */ complete = globus_l_xio_telnet_check_data(handle, &end); if(complete) { remainder = handle->read_buffer_ndx - end; if(handle->create_buffer_mode) { len = end; handle->user_read_iovec->iov_base = globus_malloc(len); memcpy(handle->user_read_iovec->iov_base, handle->read_buffer, len); handle->user_read_iovec->iov_len = len; } else { if(handle->user_read_iovec->iov_len >= end) { len = end; } else { diff = end - handle->user_read_iovec->iov_len; len = handle->user_read_iovec->iov_len; end -= diff; remainder += diff; } memcpy(handle->user_read_iovec->iov_base, handle->read_buffer, len); } /* move remainder to the begining of the buffer */ if(remainder > 0) { memmove(handle->read_buffer, &handle->read_buffer[end], remainder); } handle->read_buffer_ndx = remainder; handle->finish = GLOBUS_TRUE; handle->finish_len = len; handle->finish_res = GLOBUS_SUCCESS; } else { if(handle->read_buffer_ndx + 1 >= handle->read_buffer_length) { handle->read_buffer_length *= 2; handle->read_buffer = globus_libc_realloc( handle->read_buffer, handle->read_buffer_length); } handle->read_iovec.iov_base = &handle->read_buffer[handle->read_buffer_ndx]; handle->read_iovec.iov_len = handle->read_buffer_length - handle->read_buffer_ndx; res = globus_xio_driver_pass_read( op, &handle->read_iovec, 1, 1, globus_l_xio_telnet_read_cb, handle); if(res != GLOBUS_SUCCESS) { goto err; } } return; err: handle->finish = GLOBUS_TRUE; handle->finish_len = 0; handle->finish_res = res; }
/* * In coming buffer may shrink, if there are telnet commands in the * buffer write commands are added to the write queue. */ static globus_bool_t globus_l_xio_telnet_check_data( globus_l_xio_telnet_handle_t * handle, globus_size_t * length) { globus_bool_t done = GLOBUS_FALSE; globus_size_t len; int ndx; globus_byte_t * buffer; len = handle->read_buffer_ndx; buffer = handle->read_buffer; ndx = 0; while(ndx < len && !done) { if(handle->last_char == GLOBUS_XIO_TELNET_IAC) { switch(buffer[ndx]) { case GLOBUS_XIO_TELNET_WILL: handle->write_buffer = globus_malloc(3); handle->write_buffer[0] = GLOBUS_XIO_TELNET_IAC; handle->write_buffer[1] = GLOBUS_XIO_TELNET_DONT; break; case GLOBUS_XIO_TELNET_DO: handle->write_buffer = globus_malloc(3); handle->write_buffer[0] = GLOBUS_XIO_TELNET_IAC; handle->write_buffer[1] = GLOBUS_XIO_TELNET_WONT; break; /* 2 byte commands */ default: /* do not copy a byte */ break; } handle->last_char = buffer[ndx]; len--; if(ndx < len) { memmove(&buffer[ndx], &buffer[ndx + 1], len - ndx); } } else if(handle->last_char == GLOBUS_XIO_TELNET_WILL || handle->last_char == GLOBUS_XIO_TELNET_DO) { if(handle->write_buffer != NULL) { handle->write_buffer[2] = buffer[ndx]; globus_fifo_enqueue(&handle->write_q, handle->write_buffer); handle->write_buffer = NULL; } handle->last_char = buffer[ndx]; len--; if(ndx < len) { memmove(&buffer[ndx], &buffer[ndx + 1], len - ndx); } } else if(handle->last_char == GLOBUS_XIO_TELNET_WONT || handle->last_char == GLOBUS_XIO_TELNET_DO) { handle->last_char = buffer[ndx]; len--; if(ndx < len) { memmove(&buffer[ndx], &buffer[ndx + 1], len - ndx); } } else if((buffer[ndx] >= 32 && buffer[ndx] <= 126) || buffer[ndx] == GLOBUS_XIO_TELNET_NULL || buffer[ndx] == GLOBUS_XIO_TELNET_BELL || buffer[ndx] == GLOBUS_XIO_TELNET_BS || buffer[ndx] == GLOBUS_XIO_TELNET_HT || buffer[ndx] == GLOBUS_XIO_TELNET_CR || buffer[ndx] == GLOBUS_XIO_TELNET_VT || buffer[ndx] == GLOBUS_XIO_TELNET_FF) { handle->last_char = buffer[ndx]; ndx++; } else if(buffer[ndx] == GLOBUS_XIO_TELNET_LF && handle->last_char == GLOBUS_XIO_TELNET_CR) { if(handle->client) /* do special ftp checking here */ { if(ndx < handle->line_start_ndx + 5 || handle->read_buffer[handle->line_start_ndx+3] == ' ') { handle->line_start_ndx = 0; handle->last_char = '\0'; done = GLOBUS_TRUE; } else { handle->line_start_ndx = ndx+1; handle->last_char = buffer[ndx]; } } else { handle->last_char = '\0'; done = GLOBUS_TRUE; } ndx++; } else { handle->last_char = buffer[ndx]; len--; if(ndx < len) { memmove(&buffer[ndx], &buffer[ndx + 1], len - ndx); } } } handle->read_buffer_ndx = len; *length = ndx; return done; }
globus_object_t * globus_i_ftp_client_wrap_ftp_error( globus_module_descriptor_t * base_source, int code, const char * message, int error_type, const char * source_file, const char * source_func, int source_line, const char * format, ...) { va_list ap; globus_object_t * error; globus_object_t * causal_error; globus_l_error_ftp_data_t * data; causal_error = globus_object_construct(GLOBUS_ERROR_TYPE_FTP); if(!causal_error) { goto error_object; } data = (globus_l_error_ftp_data_t *) globus_malloc(sizeof(globus_l_error_ftp_data_t)); if(!data) { goto error_data; } data->code = code; data->message = globus_libc_strdup(message); globus_object_set_local_instance_data(causal_error, data); globus_error_initialize_base(causal_error, base_source, NULL); va_start(ap, format); error = globus_error_v_construct_error( base_source, causal_error, error_type, source_file, source_func, source_line, format, ap); va_end(ap); if(!error) { goto error_construct; } return error; error_construct: error_data: globus_object_free(causal_error); error_object: return NULL; }