/* * 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; }
void session_destroy_session_info(globus_gfs_session_info_t * SessionInfo) { GlobusGFSName(__func__); GlobusGFSHpssDebugEnter(); if (SessionInfo->username != NULL) globus_free(SessionInfo->username); if (SessionInfo->password != NULL) globus_free(SessionInfo->password); if (SessionInfo->subject != NULL) globus_free(SessionInfo->subject); if (SessionInfo->cookie != NULL) globus_free(SessionInfo->cookie); if (SessionInfo->host_id != NULL) globus_free(SessionInfo->host_id); SessionInfo->username = NULL; SessionInfo->password = NULL; SessionInfo->subject = NULL; SessionInfo->cookie = NULL; SessionInfo->host_id = NULL; GlobusGFSHpssDebugExit(); }
globus_result_t globus_gridftp_server_control_set_cwd( globus_gridftp_server_control_t server, const char * cwd_string) { GlobusGridFTPServerName(globus_gridftp_server_control_get_cwd); if(server == NULL) { return GlobusGridFTPServerErrorParameter("server"); } globus_mutex_lock(&server->mutex); { if(cwd_string) { if(server->cwd) { globus_free(server->cwd); } server->cwd = strdup(cwd_string); } else if(server->cwd) { if(server->default_cwd) { globus_free(server->default_cwd); } server->default_cwd = strdup(server->cwd); } } globus_mutex_unlock(&server->mutex); return GLOBUS_SUCCESS; }
void globus_xio_driver_list_destroy( globus_list_t * driver_list, globus_bool_t unload) { globus_xio_driver_list_ent_t * ent; globus_list_t * list; for(list = driver_list; !globus_list_empty(list); list = globus_list_rest(list)) { ent = (globus_xio_driver_list_ent_t *) globus_list_first(list); if(ent->driver_name != NULL) { globus_free(ent->driver_name); } if(ent->opts != NULL) { globus_free(ent->opts); } if(unload) { globus_xio_driver_unload(ent->driver); } globus_free(ent); } }
static void gfork_l_client_writev_cb( globus_xio_handle_t xio_handle, globus_result_t result, globus_xio_iovec_t * iovec, int count, globus_size_t nbytes, globus_xio_data_descriptor_t data_desc, void * user_arg) { gfork_i_msg_t * msg; gfork_i_lib_handle_t * handle; msg = (gfork_i_msg_t *) user_arg; handle = msg->lib_handle; /* lazy reuse of XIO callback. perhaps we should define our own */ if(msg->client_cb) { msg->client_cb(NULL, result, &msg->iov[1], count - 1, nbytes, data_desc, msg->user_arg); } globus_free(msg->iov); globus_free(msg); globus_mutex_lock(&handle->mutex); { handle->writing = GLOBUS_FALSE; if(result != GLOBUS_SUCCESS) { goto error; } if(!globus_fifo_empty(&handle->write_q)) { msg = (gfork_i_msg_t *) globus_fifo_dequeue(&handle->write_q); result = globus_xio_register_writev( handle->write_xio, msg->iov, msg->iovc, msg->nbytes, NULL, gfork_l_client_writev_cb, msg); if(result != GLOBUS_SUCCESS) { goto error; } handle->writing = GLOBUS_TRUE; } } globus_mutex_unlock(&handle->mutex); return; error: assert(0); globus_mutex_unlock(&handle->mutex); }
void stat_destroy(globus_gfs_stat_t * GFSStat) { if (GFSStat) { if (GFSStat->symlink_target != NULL) globus_free(GFSStat->symlink_target); if (GFSStat->name != NULL) globus_free(GFSStat->name); } return; }
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; }
static void globus_l_error_ftp_free( void * data) { globus_l_error_ftp_data_t * d; d = (globus_l_error_ftp_data_t *) data; if(d->message) { globus_free(d->message); } globus_free(d); }
static void gfs_l_xio_cp_post_read( globus_xio_handle_t xio_h, gfs_l_xio_read_buffer_t * read_buf) { globus_result_t result; read_buf->read_xio = xio_h; result = globus_xio_register_read( xio_h, read_buf->buffer, read_buf->block_size, read_buf->block_size, gfs_l_xio_cp_read_cb, NULL, read_buf); if(result != GLOBUS_SUCCESS) { goto error; } return; error: globus_free(read_buf); gfs_l_xio_cp_error(cp_h, result); globus_mutex_unlock(&cp_h->mutex); }
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 void bounce_handle_destroy( bounce_handle_t * handle) { globus_mutex_destroy(&handle->mutex); globus_free(handle); }
globus_result_t globus_xio_stack_destroy( globus_xio_stack_t stack) { globus_result_t res; GlobusXIOName(globus_xio_stack_destroy); GlobusXIODebugEnter(); if(stack == NULL) { res = GlobusXIOErrorParameter("stack"); goto err; } globus_list_free(stack->driver_stack); globus_free(stack); GlobusXIODebugExit(); return GLOBUS_SUCCESS; err: GlobusXIODebugExitWithError(); return res; }
/****************************************************************************** Function: globus_l_gass_server_ez_put_callback() Description: Parameters: Returns: ******************************************************************************/ static void globus_l_gass_server_ez_put_callback( void *arg, globus_gass_transfer_request_t request, globus_byte_t * bytes, globus_size_t len, globus_bool_t last_data) { int fd; fd = (int) arg; globus_libc_write(fd, bytes, len); if(!last_data) { globus_gass_transfer_receive_bytes(request, bytes, 1024, 1, globus_l_gass_server_ez_put_callback, arg); return ; } if((fd!=fileno(stdout)) && (fd!=fileno(stderr))) { close(fd); } globus_free(bytes); globus_gass_transfer_request_destroy(request); return ; } /* globus_l_gass_server_ez_put_callback() */
static void gfs_l_dynclient_log( globus_result_t result, int level, char * fmt, ...) { va_list ap; if(g_quiet) { return; } va_start(ap, fmt); fprintf(stderr, "[gridftp gfork plugin] : "); if(result != GLOBUS_SUCCESS) { char * err_str = globus_error_print_friendly( globus_error_peek(result)); fprintf(stderr, "ERROR : %s : ", err_str); globus_free(err_str); } vfprintf(stderr, fmt, ap); va_end(ap); fflush(stderr); }
void transfer_control_destroy(transfer_control_t * TransferControl) { GlobusGFSName(__func__); GlobusGFSHpssDebugEnter(); if (TransferControl != NULL) { /* Unregister to receive messages. */ msg_unregister(TransferControl->MsgHandle, TransferControl->MsgRegisterID); /* Destroy the PIO control handle. */ pio_control_destroy(TransferControl->PioControl); /* * Temp workaround to make sure the thread that called us isn't still * holding this lock. */ globus_mutex_lock(&TransferControl->Lock); globus_mutex_unlock(&TransferControl->Lock); /* Dellocate the lock. */ globus_mutex_destroy(&TransferControl->Lock); /* Destroy the transfer range list. */ range_list_destroy(TransferControl->TransferRangeList); /* Deallocate our handle. */ globus_free(TransferControl); } GlobusGFSHpssDebugExit(); }
void * globus_extension_registry_remove( globus_extension_registry_t * registry, void * symbol) { globus_l_extension_handle_t * entry; void * datum = NULL; GlobusFuncName(globus_extension_registry_remove); GlobusExtensionDebugEnterSymbol(registry->user_hashing ? "" : symbol); globus_rmutex_lock(&globus_l_extension_mutex); { if(registry->initialized) { entry = (globus_l_extension_handle_t *) globus_hashtable_lookup(®istry->table, (void *) symbol); if(entry && entry->datum) { datum = entry->datum; globus_hashtable_remove(®istry->table, (void *) symbol); if(--entry->ref == 0) { globus_free(entry); } } } } globus_rmutex_unlock(&globus_l_extension_mutex); GlobusExtensionDebugExit(); return datum; }
globus_result_t globus_gridftp_server_control_attr_add_mode( globus_gridftp_server_control_attr_t in_attr, char mode) { char ch; char * tmp_str; globus_i_gsc_attr_t * attr; globus_result_t res; GlobusGridFTPServerName(globus_gridftp_server_control_attr_add_mode); GlobusGridFTPServerDebugEnter(); if(in_attr == NULL) { res = GlobusGridFTPServerErrorParameter("in_attr"); goto err; } attr = in_attr; ch = toupper(mode); tmp_str = globus_common_create_string("%s%c", attr->modes, ch); globus_free(attr->modes); attr->modes = tmp_str; GlobusGridFTPServerDebugExit(); return GLOBUS_SUCCESS; err: GlobusGridFTPServerDebugExitWithError(); return res; }
/* stalled transfer timer has ended */ static void l_ticker_done( void * user_arg) { globus_free(user_arg); }
void globus_xio_system_socket_destroy( globus_xio_system_socket_handle_t handle) { unsigned long flag = 0; GlobusXIOName(globus_xio_system_socket_destroy); GlobusXIOSystemDebugEnterFD(handle->socket); globus_assert(!handle->read_info && !handle->write_info); /* no need to ensure entry is still registered, as I always return true * in the callback and this is only place i unregister */ globus_i_xio_win32_event_lock(handle->event_entry); GlobusXIOSystemDebugPrintf( GLOBUS_I_XIO_SYSTEM_DEBUG_INFO, ("[%s] Unregistering event handle=%lu for socket %ld\n", _xio_name, (unsigned long) handle->event, (long) handle->socket)); globus_i_xio_win32_event_unregister(handle->event_entry); globus_i_xio_win32_event_unlock(handle->event_entry); WSAEventSelect(handle->socket, 0, 0); ioctlsocket(handle->socket, FIONBIO, &flag); WSACloseEvent(handle->event); win32_mutex_destroy(&handle->lock); GlobusXIOSystemDebugExitFD(handle->socket); globus_free(handle); }
static void globus_l_gsc_send_perf( globus_gridftp_server_control_op_t op, int stripe_ndx, int stripe_count, globus_off_t nbytes) { char * msg; struct timeval now; GlobusGridFTPServerName(globus_l_gsc_send_perf); gettimeofday(&now, NULL); msg = globus_common_create_string( "112-Perf Marker\r\n" " Timestamp: %ld.%01ld\r\n" " Stripe Index: %d\r\n" " Stripe Bytes Transferred: %"GLOBUS_OFF_T_FORMAT"\r\n" " Total Stripe Count: %d\r\n" "112 End.\r\n", now.tv_sec, now.tv_usec / 100000, stripe_ndx, nbytes, stripe_count); globus_i_gsc_intermediate_reply(op, msg); globus_free(msg); }
static void globus_l_gsc_event_done_cb( void * user_arg) { globus_i_gsc_op_t * op; globus_i_gsc_event_data_t * event; globus_i_gsc_server_handle_t * server_handle; op = (globus_i_gsc_op_t *) user_arg; event = &op->event; server_handle = op->server_handle; event->user_cb( op, GLOBUS_GRIDFTP_SERVER_CONTROL_EVENT_TRANSFER_COMPLETE, event->user_arg); if(event->stripe_total != NULL) { globus_free(event->stripe_total); } globus_mutex_lock(&server_handle->mutex); { if(op->data_destroy_obj) { globus_i_guc_data_object_destroy( op->server_handle, op->data_destroy_obj); } globus_i_gsc_op_destroy(op); } globus_mutex_unlock(&server_handle->mutex); }
static int globus_l_usage_stats_split_targets( const char * targets_string, globus_list_t ** targets) { char * tmpstr; char * target; char * ptr; if(targets_string == NULL) { return -1; } tmpstr = globus_libc_strdup(targets_string); target = tmpstr; while((ptr = strchr(target, ',')) != NULL || (ptr = strchr(target, ' ')) != NULL) { *ptr = '\0'; globus_list_insert(targets, globus_libc_strdup(target)); target = ptr + 1; } if(ptr == NULL) { globus_list_insert(targets, globus_libc_strdup(target)); } globus_free(tmpstr); return 0; }
static void xio_l_wrapblock_wrapper_destroy( xio_l_wrapblock_wrapper_t * wrapper) { globus_xio_contact_destroy(&wrapper->ci); if(wrapper->iovec != NULL) { globus_free(wrapper->iovec); } if(wrapper->attr && wrapper->driver && wrapper->driver->attr_destroy_func) { wrapper->driver->attr_destroy_func(wrapper->attr); } globus_free(wrapper); }
/** * Destroy an instance of the GridFTP restart plugin * @ingroup globus_ftp_client_restart_plugin * * This function will free all restart plugin-specific instance data * from this plugin, and will make the plugin unusable for further ftp * handle creation. * * Existing FTP client handles and handle attributes will not be affected by * destroying a plugin associated with them, as a local copy of the plugin * is made upon handle initialization. * * @param plugin * A pointer to a GridFTP restart plugin, previously initialized by * calling globus_ftp_client_restart_plugin_init() * * @return This function returns an error if * - plugin is null * - plugin is not a restart plugin * * @see globus_ftp_client_restart_plugin_init(), * globus_ftp_client_handleattr_add_plugin(), * globus_ftp_client_handleattr_remove_plugin(), * globus_ftp_client_handle_init() */ globus_result_t globus_ftp_client_restart_plugin_destroy( globus_ftp_client_plugin_t * plugin) { globus_l_ftp_client_restart_plugin_t * d; globus_result_t result; GlobusFuncName(globus_ftp_client_restart_plugin_destroy); GLOBUS_L_FTP_CLIENT_RESTART_PLUGIN_RETURN(plugin); result = globus_ftp_client_plugin_get_plugin_specific(plugin, (void **) &d); if(result != GLOBUS_SUCCESS) { return result; } globus_l_ftp_client_restart_plugin_genericify(d); if(d->ticker_set) { d->ticker_set = GLOBUS_FALSE; /* XXX where is d freed? if was a previous leak free in l_ticker_done */ globus_callback_unregister( d->ticker_handle, l_ticker_done, d, NULL); } else { /* XXX free d here ? */ globus_free(d); } return globus_ftp_client_plugin_destroy(plugin); }
void globus_extension_release( globus_extension_handle_t handle) { globus_l_extension_handle_t * entry; globus_l_extension_module_t * owner = NULL; GlobusFuncName(globus_extension_release); entry = handle; GlobusExtensionDebugEnterSymbol(entry->user_hashing ? "" : entry->symbol); globus_rmutex_lock(&globus_l_extension_mutex); { if(entry) { if(entry->owner && --entry->owner->ref == 0) { owner = entry->owner; } if(--entry->ref == 0) { globus_free(entry); } if(owner) { globus_l_extension_shutdown_extension(owner, GLOBUS_FALSE); } } } globus_rmutex_unlock(&globus_l_extension_mutex); GlobusExtensionDebugExit(); }
/* XX this is crap.. no idea how big host is. should probably be at least * 50 bytes */ void globus_ftp_control_host_port_get_host( globus_ftp_control_host_port_t * host_port, char * host) { char * str; /* this api doesnt let me play nice with people that arent aware of the new * hostlen field in host_port. since i have tried to assume 4 wherever * ipv6 is not allowed, I will assume 4 unless the len is actually 16. * this is in the hopes that it is not likely for a random unitialized int * to be 16 */ str = globus_libc_ints_to_contact_string( host_port->host, host_port->hostlen == 16 ? 16 : 4, 0); if(str) { strcpy(host, str); globus_free(str); } else { *host = 0; } }
static void globus_l_xio_telnet_cmd_write_cb( globus_xio_operation_t op, globus_result_t result, globus_size_t nbytes, void * user_arg) { globus_l_xio_telnet_handle_t * handle; handle = (globus_l_xio_telnet_handle_t *) user_arg; if(result != GLOBUS_SUCCESS) { globus_xio_driver_finished_read(op, result, 0); return; } globus_mutex_lock(&handle->mutex); { globus_free(handle->write_iovec.iov_base); globus_l_xio_telnet_request_data(handle, op); } globus_mutex_unlock(&handle->mutex); if(handle->finish) { handle->finish = GLOBUS_FALSE; globus_xio_driver_finished_read( op, handle->finish_res, handle->finish_len); } }
static globus_result_t globus_l_xio_telnet_attr_destroy( void * driver_attr) { globus_free(driver_attr); return GLOBUS_SUCCESS; }
static void globus_l_xio_telnet_close_cb( globus_xio_operation_t op, globus_result_t result, void * user_arg) { globus_l_xio_telnet_handle_t * handle; handle = (globus_l_xio_telnet_handle_t *) user_arg; globus_xio_driver_finished_close(op, result); globus_free(handle->read_buffer); globus_fifo_destroy(&handle->write_q); globus_mutex_destroy(&handle->mutex); globus_free(handle); }
static void globus_l_gsc_send_restart( globus_gridftp_server_control_op_t op, globus_range_list_t range_list) { int ctr; char * tmp_msg; char * msg; int size; globus_off_t offset; globus_off_t length; globus_range_list_t new_range_list; globus_range_list_merge( &new_range_list, op->perf_range_list, range_list); globus_range_list_destroy(op->perf_range_list); op->perf_range_list = new_range_list; size = globus_range_list_size(range_list); if(size < 1) { /* sending 0-0 is useless, and it causes a problem with our client when markers are sent before the retr begins msg = globus_common_create_string("111 Range Marker 0-0\r\n"); */ } else { msg = globus_common_create_string("111 Range Marker"); for(ctr = 0; ctr < size; ctr++) { globus_range_list_at(range_list, ctr, &offset, &length); tmp_msg = globus_common_create_string("%s%c%" GLOBUS_OFF_T_FORMAT"-%"GLOBUS_OFF_T_FORMAT, msg, ctr ? ',' : ' ', offset, offset + length); globus_free(msg); msg = tmp_msg; } tmp_msg = globus_common_create_string("%s%s", msg, "\r\n"); globus_free(msg); msg = tmp_msg; globus_i_gsc_intermediate_reply(op, msg); globus_free(msg); } }