/** * @brief Print Error Data * @ingroup globus_openssl_error_object * @details * Return an allocated string of the OpenSSL error from the instance data * * @param error * The error object to retrieve the data from. * @return * String containing the OpenSSL error if it exists, NULL * otherwise. */ static char * globus_l_error_openssl_printable( globus_object_t * error) { globus_openssl_error_handle_t handle; char * error_string; static char * _function_name_ = "globus_l_error_openssl_printable"; GLOBUS_I_GSI_OPENSSL_ERROR_DEBUG_ENTER; if(!error) { error_string = NULL; goto done; } handle = (globus_openssl_error_handle_t) globus_object_get_local_instance_data(error); if(globus_openssl_error_handle_get_data_flags(handle) & ERR_TXT_STRING) { error_string = globus_common_create_string( _GOESL("OpenSSL Error: %s:%d: in library: %s, function %s: %s %s"), globus_openssl_error_handle_get_filename(handle) == NULL ? "(null)" : globus_openssl_error_handle_get_filename(handle), globus_openssl_error_handle_get_linenumber(handle), globus_openssl_error_handle_get_library(handle) == NULL ? "(null)" : globus_openssl_error_handle_get_library(handle), globus_openssl_error_handle_get_function(handle) == NULL ? "(null)" : globus_openssl_error_handle_get_function(handle), globus_openssl_error_handle_get_reason(handle) == NULL ? "(null)" : globus_openssl_error_handle_get_reason(handle), globus_openssl_error_handle_get_data(handle)); } else { error_string = globus_common_create_string( _GOESL("OpenSSL Error: %s:%d: in library: %s, function %s: %s"), globus_openssl_error_handle_get_filename(handle) == NULL ? "(null)" : globus_openssl_error_handle_get_filename(handle), globus_openssl_error_handle_get_linenumber(handle), globus_openssl_error_handle_get_library(handle) == NULL ? "(null)" : globus_openssl_error_handle_get_library(handle), globus_openssl_error_handle_get_function(handle) == NULL ? "(null)" : globus_openssl_error_handle_get_function(handle), globus_openssl_error_handle_get_reason(handle) == NULL ? "(null)" : globus_openssl_error_handle_get_reason(handle)); } done: GLOBUS_I_GSI_OPENSSL_ERROR_DEBUG_EXIT; return error_string; }/* globus_l_error_openssl_printable */
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); }
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; }
static globus_bool_t globus_l_next_file_exists( globus_l_job_manager_logfile_state_t * state) { struct tm next_day; char * next_log; globus_bool_t file_exists = GLOBUS_FALSE; next_day = state->start_timestamp; next_day.tm_mday++; globus_l_job_manager_normalize_date(&next_day); next_day.tm_sec = 0; next_day.tm_min = 0; next_day.tm_hour = 0; next_log = globus_common_create_string( "%s/%4d%02d%02d", state->log_dir, next_day.tm_year+1900, next_day.tm_mon+1, next_day.tm_mday); if (access(next_log, R_OK) == 0) { file_exists = GLOBUS_TRUE; } free(next_log); return file_exists; }
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); } }
static globus_result_t globus_l_net_manager_context_load_entry( const char * name, globus_i_net_manager_context_entry_t ** entry) { globus_extension_handle_t ext_handle; globus_net_manager_t * loaded_manager; char * dll_name = NULL; globus_i_net_manager_context_entry_t * ent; int rc; globus_result_t result = GLOBUS_SUCCESS; GlobusNetManagerName(globus_l_net_manager_context_load_entry); /* is module already in registry? */ loaded_manager = (globus_net_manager_t *) globus_extension_lookup( &ext_handle, GLOBUS_NET_MANAGER_REGISTRY, (void *) name); if(loaded_manager == NULL) { /* load and activate the dll */ dll_name = globus_common_create_string( "globus_net_manager_%s", name); rc = globus_extension_activate(dll_name); if(rc != GLOBUS_SUCCESS) { result = GlobusNetManagerErrorManager( rc, name, "attempting to activate module."); goto error_activate; } /* now module should be in registry */ loaded_manager = (globus_net_manager_t *) globus_extension_lookup( &ext_handle, GLOBUS_NET_MANAGER_REGISTRY, (void *) name); if(loaded_manager == NULL) { result = GlobusNetManagerErrorManager( rc, name, "attempting to load activated module."); goto error_activate; } } ent = globus_calloc(1, sizeof(globus_i_net_manager_context_entry_t)); ent->manager = loaded_manager; ent->ext_handle = ext_handle; ent->name = strdup(name); ent->dll_name = dll_name; *entry = ent; return GLOBUS_SUCCESS; error_activate: globus_free(dll_name); *entry = NULL; return result; }
/* * PURPOSE: * Verify that * globus_gram_protocol_unpack_job_request_reply_with_extensions() * catches protocol mismatch errors. * TEST STEPS: * - Manually construct status update message with version equal to * GLOBUS_GRAM_PROTOCOL_VERSION + 1 * - Call globus_gram_protocol_unpack_job_request_reply_with_extensions() and * expect a VERSION_MISMATCH error */ int test_version_mismatch(void) { char * message; globus_size_t message_size; int rc; globus_hashtable_t hashtable; int status; char * job_contact; message = globus_common_create_string( "protocol-version: %d\r\n" "status: %d\r\n" "failure-code: %d\r\n" "job-failure-code: %d\r\n", GLOBUS_GRAM_PROTOCOL_VERSION + 1, GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE, 0, 0); test_assert(message != NULL, ("Error creating message (out of memory?)\n")); message_size = strlen(message) + 1; rc = globus_gram_protocol_unpack_job_request_reply_with_extensions( (globus_byte_t *) message, message_size, &status, &job_contact, &hashtable); test_assert(rc == GLOBUS_GRAM_PROTOCOL_ERROR_VERSION_MISMATCH, ("Expected GLOBUS_GRAM_PROTOCOL_ERROR_VERSION_MISMATCH, " "got %d (%s)\n", rc, globus_gram_protocol_error_string(rc))); if (hashtable != NULL) { globus_gram_protocol_hash_destroy(&hashtable); } free(message); return 0; }
/* * PURPOSE: * Verify that * globus_gram_protocol_unpack_job_request_reply_with_extensions() * deals with messages missing attributes from GRAM2 protocol. * TEST STEPS: * - Manually construct status update messages with each piece of the GRAM2 * protocol missing * - Call globus_gram_protocol_unpack_job_request_reply_with_extensions() and * expect an UNPACK_FAILED error */ int test_missing_attribute() { char * message; globus_size_t message_size; int rc; globus_hashtable_t hashtable; int i; char * lines[] = { "protocol-version: 2\r\n", "status: 2\r\n" }; int status; char * job_contact; for (i = 0; i < ARRAY_LEN(lines); i++) { message = globus_common_create_string( "%s", lines[i % ARRAY_LEN(lines)]); test_assert(message != NULL, ("Error creating message (out of memory?)\n")); message_size = strlen(message) + 1; rc = globus_gram_protocol_unpack_job_request_reply_with_extensions( (globus_byte_t *) message, message_size, &status, &job_contact, &hashtable); test_assert(rc == GLOBUS_GRAM_PROTOCOL_ERROR_HTTP_UNPACK_FAILED, ("Expected GLOBUS_GRAM_PROTOCOL_ERROR_HTTP_UNPACK_FAILED, " "got %d (%s)\n", rc, globus_gram_protocol_error_string(rc))); free(message); } return 0; }
int main() { globus_object_t * err; char * s; char * t; static char * myname = "main"; printf("1..1\n"); globus_module_activate(GLOBUS_COMMON_MODULE); #line myline err = globus_error_construct_string(GLOBUS_COMMON_MODULE, GLOBUS_ERROR_NO_INFO, "[%s]: Error doing something hard at %s:%d\n", GLOBUS_COMMON_MODULE->module_name, myname, __LINE__); s = globus_object_printable_to_string(err); #line myline t = globus_common_create_string( "[%s]: Error doing something hard at %s:%d\n", GLOBUS_COMMON_MODULE->module_name, myname, __LINE__); ok(strcmp(s, t) == 0, "globus_common_error_string"); free(s); free(t); return TEST_EXIT_CODE; }
extern int globus_gram_job_manager_validation_update( globus_gram_job_manager_t * manager) { time_t validation_timestamp = time(NULL); int rc = GLOBUS_SUCCESS; globus_result_t result; struct stat st; globus_bool_t do_update = GLOBUS_FALSE; if (validation_timestamp <= manager->validation_record_timestamp) { goto skip_update_check; } if (validation_filename == NULL) { result = globus_eval_path( "${datadir}/globus/globus_gram_job_manager/globus-gram-job-manager.rvf", &validation_filename); if (result != GLOBUS_SUCCESS || validation_filename == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto validation_filename_failed; } } if (site_validation_filename == NULL) { result = globus_eval_path( "${sysconfdir}/globus/gram/job-manager.rvf", &site_validation_filename); if (result != GLOBUS_SUCCESS || site_validation_filename == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto site_validation_filename_failed; } } if (lrm_validation_filename_pattern == NULL) { lrm_validation_filename_pattern = globus_common_create_string( "${datadir}/globus/globus_gram_job_manager/%s.rvf", manager->config->jobmanager_type); if(lrm_validation_filename_pattern == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto lrm_validation_filename_pattern_failed; } } if (lrm_validation_filename == NULL) { result = globus_eval_path( lrm_validation_filename_pattern, &lrm_validation_filename); if (result != GLOBUS_SUCCESS || lrm_validation_filename == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto lrm_validation_filename_failed; } } if (site_lrm_validation_filename_pattern == NULL) { site_lrm_validation_filename_pattern = globus_common_create_string( "${sysconfdir}/globus/gram/%s.rvf", manager->config->jobmanager_type); if(site_lrm_validation_filename_pattern == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto site_lrm_validation_filename_pattern_failed; } } if (site_lrm_validation_filename == NULL) { result = globus_eval_path(site_lrm_validation_filename_pattern, &site_lrm_validation_filename); if (result != GLOBUS_SUCCESS || site_lrm_validation_filename == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto site_lrm_validation_filename_failed; } } rc = stat(validation_filename, &st); if ((rc == GLOBUS_SUCCESS && ((!manager->validation_file_exists[0]) || st.st_mtime > manager->validation_record_timestamp)) || (rc != GLOBUS_SUCCESS && errno == ENOENT && manager->validation_file_exists[0])) { do_update = GLOBUS_TRUE; } if (!do_update) { rc = stat(lrm_validation_filename, &st); if ((rc == GLOBUS_SUCCESS && ((!manager->validation_file_exists[1]) || st.st_mtime > manager->validation_record_timestamp)) || (rc != GLOBUS_SUCCESS && errno == ENOENT && manager->validation_file_exists[1])) { do_update = GLOBUS_TRUE; } } if (!do_update) { rc = stat(site_validation_filename, &st); if ((rc == GLOBUS_SUCCESS && ((!manager->validation_file_exists[2]) || st.st_mtime > manager->validation_record_timestamp)) || (rc != GLOBUS_SUCCESS && errno == ENOENT && manager->validation_file_exists[2])) { do_update = GLOBUS_TRUE; } } if (!do_update) { rc = stat(site_lrm_validation_filename, &st); if ((rc == GLOBUS_SUCCESS && ((!manager->validation_file_exists[3]) || st.st_mtime > manager->validation_record_timestamp)) || (rc != GLOBUS_SUCCESS && errno == ENOENT && manager->validation_file_exists[3])) { do_update = GLOBUS_TRUE; } } if (do_update) { /* Free old validation entries */ globus_gram_job_manager_validation_destroy( manager->validation_records); manager->validation_records = NULL; rc = globus_gram_job_manager_validation_init(manager); } else { rc = GLOBUS_SUCCESS; } site_lrm_validation_filename_failed: site_lrm_validation_filename_pattern_failed: lrm_validation_filename_failed: lrm_validation_filename_pattern_failed: site_validation_filename_failed: validation_filename_failed: skip_update_check: return rc; }
/** * Validate RSL attributes * * Checks that all of the RSL attributes in the request's RSL match * a validation record. If an RSL has an enumerated list of values, * then the value of the RSL is compared against that list. * * @param request * The job request containing the RSL to validate. * @param when * Which RSL validation time scope we will use to decide * whether to use the default values or not. */ static int globus_l_gram_job_manager_check_rsl_attributes( globus_gram_jobmanager_request_t * request, globus_rsl_t * rsl, globus_gram_job_manager_validation_when_t when) { globus_list_t * operands; globus_list_t * node; globus_rsl_t * relation; char * attribute; char * value_str; globus_rvf_record_t * record; globus_rsl_value_t * value; int rc = GLOBUS_SUCCESS; static const char * operation_types[] = { "??", "=", "!=", ">", ">=", "<", "<=", "??", "&", "|", "+" }; operands = globus_rsl_boolean_get_operand_list(rsl); /* Check to make sure that every attribute is recognized by this * job manager. */ while(!globus_list_empty(operands)) { relation = globus_list_first(operands); operands = globus_list_rest(operands); if (!globus_rsl_is_relation(relation)) { int operator = globus_rsl_boolean_get_operator(relation); if (operator > 10 || operator < 0) { operator = 0; } globus_gram_job_manager_request_log( request, GLOBUS_GRAM_JOB_MANAGER_LOG_ERROR, "event=gram.validate_rsl.end " "level=ERROR " "msg=\"Required RSL relation, got boolean\" " "operator=%s " "status=%d " "\n", operation_types[operator], -GLOBUS_GRAM_PROTOCOL_ERROR_BAD_RSL); if (request->gt3_failure_message == NULL) { request->gt3_failure_message = globus_common_create_string( "Required RSL relation, got boolean %s", operation_types[operator]); } } else if (!globus_rsl_is_relation_eq(relation)) { int operator = globus_rsl_relation_get_operator(relation); if (operator > 10 || operator < 0) { operator = 0; } globus_gram_job_manager_request_log( request, GLOBUS_GRAM_JOB_MANAGER_LOG_ERROR, "event=gram.validate_rsl.end " "level=ERROR " "msg=\"Unsupported RSL operation\" " "attribute=%s " "operator=%s " "status=%d " "\n", globus_rsl_relation_get_attribute(relation), operation_types[operator], -GLOBUS_GRAM_PROTOCOL_ERROR_BAD_RSL); if (request->gt3_failure_message == NULL) { request->gt3_failure_message = globus_common_create_string( "the job manager does not support the RSL operator " "\"%s\" for the %s attribute", operation_types[operator], globus_rsl_relation_get_attribute(relation)); } return GLOBUS_GRAM_PROTOCOL_ERROR_BAD_RSL; } attribute = globus_rsl_relation_get_attribute(relation); node = globus_list_search_pred( request->manager->validation_records, globus_l_gram_job_manager_attribute_match, attribute); if(!node) { globus_gram_job_manager_request_log( request, GLOBUS_GRAM_JOB_MANAGER_LOG_ERROR, "event=gram.validate_rsl.end " "level=ERROR " "msg=\"Unsupported RSL attribute\" " "attribute=%s " "status=%d " "\n", globus_rsl_relation_get_attribute(relation), -GLOBUS_GRAM_PROTOCOL_ERROR_BAD_RSL); if (request->gt3_failure_message == NULL) { request->gt3_failure_message = globus_common_create_string( "the RSL attribute \"%s\" is not supported by the LRM adapter", globus_rsl_relation_get_attribute(relation)); } return GLOBUS_GRAM_PROTOCOL_ERROR_PARAMETER_NOT_SUPPORTED; } record = globus_list_first(node); /* Check valid_when */ if((record->valid_when & when) == 0) { const char * whenstr = "unknown operation"; switch(when) { case GLOBUS_GRAM_VALIDATE_JOB_SUBMIT: whenstr = "submit"; rc = GLOBUS_GRAM_PROTOCOL_ERROR_INVALID_SUBMIT_ATTRIBUTE; break; case GLOBUS_GRAM_VALIDATE_JOB_MANAGER_RESTART: whenstr = "restart"; rc = GLOBUS_GRAM_PROTOCOL_ERROR_INVALID_RESTART_ATTRIBUTE; break; case GLOBUS_GRAM_VALIDATE_STDIO_UPDATE: whenstr = "stdio_update"; rc = GLOBUS_GRAM_PROTOCOL_ERROR_INVALID_STDIO_UPDATE_ATTRIBUTE; break; } globus_gram_job_manager_request_log( request, GLOBUS_GRAM_JOB_MANAGER_LOG_ERROR, "event=gram.validate_rsl.end " "level=ERROR " "msg=\"Invalid RSL attribute for operation\" " "attribute=%s " "operation=%s " "status=%d " "\n", globus_rsl_relation_get_attribute(relation), whenstr, -rc); if (request->gt3_failure_message == NULL) { request->gt3_failure_message = globus_common_create_string( "Invalid RSL attribute \"%s\" for %s", globus_rsl_relation_get_attribute(relation), whenstr); } return rc; } /* Check enumerated values if applicable */ if(record->enumerated_values) { value = globus_rsl_relation_get_single_value(relation); if(!value) { return globus_l_gram_job_manager_validation_rsl_error(attribute); } value_str = globus_rsl_value_literal_get_string(value); if(!value_str) { return globus_l_gram_job_manager_validation_rsl_error( attribute); } if(strstr(record->enumerated_values, value_str) == GLOBUS_NULL) { rc = globus_l_gram_job_manager_validation_value_error( request, attribute, value_str, record->enumerated_values); globus_gram_job_manager_request_log( request, GLOBUS_GRAM_JOB_MANAGER_LOG_ERROR, "event=gram.validate_rsl.end " "level=ERROR " "msg=\"RSL attribute value not in enumeration\" " "attribute=%s " "value=%s " "enumeration=\"%s\" " "status=%d " "\n", record->attribute, value_str, record->enumerated_values, -rc); return rc; } } } return GLOBUS_SUCCESS; }
int main( int argc, char ** argv) { int rc; globus_gram_job_manager_config_t config; globus_gram_job_manager_t manager; char * sleeptime_str; long sleeptime = 0; globus_bool_t debug_mode_service = GLOBUS_FALSE; globus_bool_t located_active_jm = GLOBUS_FALSE; int http_body_fd = -1; int context_fd = -1; gss_cred_id_t cred = GSS_C_NO_CREDENTIAL; OM_uint32 major_status, minor_status; pid_t forked_starter = 0; globus_bool_t cgi_invoked = GLOBUS_FALSE; int lock_tries_left = 10; if ((sleeptime_str = getenv("GLOBUS_JOB_MANAGER_SLEEP"))) { sleeptime = atoi(sleeptime_str); sleep(sleeptime); } if (getenv("GATEWAY_INTERFACE")) { cgi_invoked = GLOBUS_TRUE; } /* * Stdin and stdout point at socket to client * Make sure no buffering. * stderr may also, depending on the option in the grid-services */ setbuf(stdout,NULL); /* Don't export these to the perl scripts */ fcntl(STDIN_FILENO, F_SETFD, (int) 1); fcntl(STDOUT_FILENO, F_SETFD, (int) 1); fcntl(STDERR_FILENO, F_SETFD, (int) 1); /* * At least have minimal POSIX path for job environment via extra * environment values */ if(getenv("PATH") == NULL) { char * path; char default_path[] = "/usr/bin:/bin"; size_t pathlen; pathlen = confstr(_CS_PATH, NULL, (size_t) 0); if (pathlen < sizeof(default_path)) { pathlen = sizeof(default_path); } path = malloc(pathlen); path[0] = 0; (void) confstr(_CS_PATH, path, pathlen); if (path[0] == 0) { strncpy(path, default_path, pathlen); } setenv("PATH", path, 1); } /* Force non-threaded execution for now */ globus_thread_set_model(GLOBUS_THREAD_MODEL_NONE); /* Activate a common before parsing command-line so that * things work. Note that we can't activate everything yet because we might * set the GLOBUS_TCP_PORT_RANGE after parsing command-line args and we * need that set before activating XIO. */ rc = globus_module_activate(GLOBUS_COMMON_MODULE); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "Error activating GLOBUS_COMMON_MODULE\n"); exit(1); } /* Parse command line options to get jobmanager configuration */ rc = globus_gram_job_manager_config_init(&config, argc, argv); if (rc != GLOBUS_SUCCESS) { reply_and_exit(NULL, rc, NULL); } globus_thread_key_create( &globus_i_gram_request_key, NULL); rc = globus_gram_job_manager_logging_init(&config); if (rc != GLOBUS_SUCCESS) { exit(1); } if (getenv("GRID_SECURITY_HTTP_BODY_FD") == NULL && !cgi_invoked) { debug_mode_service = GLOBUS_TRUE; } /* Set environment variables from configuration */ if(config.globus_location != NULL) { globus_libc_setenv("GLOBUS_LOCATION", config.globus_location, GLOBUS_TRUE); } if(config.tcp_port_range != NULL) { globus_libc_setenv("GLOBUS_TCP_PORT_RANGE", config.tcp_port_range, GLOBUS_TRUE); } if(config.tcp_source_range != NULL) { globus_libc_setenv("GLOBUS_TCP_SOURCE_RANGE", config.tcp_source_range, GLOBUS_TRUE); } /* Activate all of the modules we will be using */ rc = globus_l_gram_job_manager_activate(); if(rc != GLOBUS_SUCCESS) { exit(1); } /* * Get the delegated credential (or the default credential if we are * run without a client. Don't care about errors in the latter case. */ major_status = globus_gss_assist_acquire_cred( &minor_status, GSS_C_BOTH, &cred); if ((!debug_mode_service) && GSS_ERROR(major_status)) { globus_gss_assist_display_status( stderr, "Error acquiring security credential\n", major_status, minor_status, 0); exit(1); } if (cred != GSS_C_NO_CREDENTIAL) { unsigned long hash; char * newtag; rc = globus_gram_gsi_get_dn_hash( cred, &hash); if (rc == GLOBUS_SUCCESS) { newtag = globus_common_create_string("%s%s%lx", strcmp(config.service_tag, "untagged") == 0 ? "" : config.service_tag, strcmp(config.service_tag, "untagged") == 0 ? "" : ".", hash); free(config.service_tag); config.service_tag = newtag; } } /* * Remove delegated proxy from disk. */ if ((!debug_mode_service) && getenv("X509_USER_PROXY") != NULL) { remove(getenv("X509_USER_PROXY")); unsetenv("X509_USER_PROXY"); } /* Set up LRM-specific state based on our configuration. This will create * the job contact listener, start the SEG if needed, and open the log * file if needed. */ rc = globus_gram_job_manager_init(&manager, cred, &config); if(rc != GLOBUS_SUCCESS) { reply_and_exit(NULL, rc, manager.gt3_failure_message); } /* * Pull out file descriptor numbers for security context and job request * from the environment (set by the gatekeeper) */ if (cgi_invoked) { http_body_fd = 0; context_fd = -1; } else if (!debug_mode_service) { char * fd_env = getenv("GRID_SECURITY_HTTP_BODY_FD"); rc = sscanf(fd_env ? fd_env : "-1", "%d", &http_body_fd); if (rc != 1 || http_body_fd < 0) { fprintf(stderr, "Error locating http body fd\n"); exit(1); } fcntl(http_body_fd, F_SETFD, 1); fd_env = getenv("GRID_SECURITY_CONTEXT_FD"); rc = sscanf(fd_env ? fd_env : "-1", "%d", &context_fd); if (rc != 1 || context_fd < 0) { fprintf(stderr, "Error locating security context fd\n"); exit(1); } fcntl(context_fd, F_SETFD, 1); } /* Redirect stdin from /dev/null, we'll handle stdout after the reply is * sent */ if (!cgi_invoked) { freopen("/dev/null", "r", stdin); } /* Here we'll either become the active job manager to process all * jobs for this user/host/lrm combination, or we'll hand off the * file descriptors containing the info to the active job manager */ while (!located_active_jm) { /* We'll try to get the lock file associated with being the * active job manager here. If we get the OLD_JM_ALIVE error * somebody else has it */ rc = globus_gram_job_manager_startup_lock( &manager, &manager.lock_fd); if (rc == GLOBUS_SUCCESS) { /* We've acquired the lock. We will fork a new process to act like * all other job managers which don't have the lock, and continue * on in this process managing jobs for this LRM. Note that the * child process does not inherit the lock */ if (!debug_mode_service) { int save_errno = 0; /* We've acquired the manager lock */ forked_starter = fork(); save_errno = errno; if (forked_starter < 0) { if (sleeptime != 0) { sleep(sleeptime); } fprintf(stderr, "fork failed: %s", strerror(save_errno)); exit(1); } else if (forked_starter == 0) { /* We are the child process. We'll close our reference to * the lock and let the other process deal with jobs */ close(manager.lock_fd); manager.lock_fd = -1; } globus_logging_update_pid(); if (sleeptime != 0) { sleep(sleeptime); } } if (manager.lock_fd >= 0) { /* We hold the manager lock, so we'll store our credential, and * then, try to accept socket connections. If the socket * connections fail, we'll exit, and another process * will be forked to handle them. */ rc = globus_gram_job_manager_gsi_write_credential( NULL, cred, manager.cred_path); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "write cred failed\n"); exit(1); } if (!debug_mode_service) { close(http_body_fd); http_body_fd = -1; } rc = globus_gram_job_manager_startup_socket_init( &manager, &manager.active_job_manager_handle, &manager.socket_fd); if (rc != GLOBUS_SUCCESS) { /* This releases our lock. Either the child process will * attempt to acquire the lock again or some another job * manager will acquire the lock */ exit(0); } assert(manager.socket_fd != -1); } } else if (rc != GLOBUS_GRAM_PROTOCOL_ERROR_OLD_JM_ALIVE) { /* Some system error. Try again */ if (--lock_tries_left == 0) { reply_and_exit(NULL, rc, "Unable to create lock file"); } sleep(1); continue; } /* If manager.socket_fd != -1 then we are the main job manager for this * LRM. * We will restart all existing jobs and then allow the startup * socket to accept new jobs from other job managers. */ if (manager.socket_fd != -1) { /* Look up cputype/manufacturer if not known yet */ globus_l_gram_cputype_and_manufacturer(manager.config); GlobusTimeAbstimeGetCurrent(manager.usagetracker->jm_start_time); globus_i_gram_usage_stats_init(&manager); globus_i_gram_usage_start_session_stats(&manager); located_active_jm = GLOBUS_TRUE; /* Load existing jobs. The show must go on if this fails, unless it * fails with a misconfiguration error */ rc = globus_gram_job_manager_request_load_all( &manager); if (rc == GLOBUS_GRAM_PROTOCOL_ERROR_GATEKEEPER_MISCONFIGURED) { if (forked_starter > 0) { kill(forked_starter, SIGTERM); forked_starter = 0; } reply_and_exit(NULL, rc, manager.gt3_failure_message); } if (context_fd != -1) { close(context_fd); context_fd = -1; } freopen("/dev/null", "a", stdout); /* At this point, seg_last_timestamp is the earliest last timestamp * for any pre-existing jobs. If that is 0, then we don't have any * existing jobs so we'll just ignore seg events prior to now. */ if (manager.seg_last_timestamp == 0) { manager.seg_last_timestamp = time(NULL); } /* Start off the SEG if we need it. */ if (config.seg_module != NULL || strcmp(config.jobmanager_type, "fork") == 0 || strcmp(config.jobmanager_type, "condor") == 0) { rc = globus_gram_job_manager_init_seg(&manager); /* TODO: If SEG load fails and load_all added some to the * job_id hash, they will need to be pushed into the state * machine so that polling fallback can happen. */ if (rc != GLOBUS_SUCCESS) { config.seg_module = NULL; } } /* GRAM-128: * Register a periodic event to process the GRAM jobs that were * reloaded from their job state files at job manager start time. * This will acquire and then release a reference to each job, * which, behind the scenes, will kick of the state machine * for that job if needed. */ if (!globus_list_empty(manager.pending_restarts)) { globus_reltime_t restart_period; GlobusTimeReltimeSet(restart_period, 1, 0); rc = globus_callback_register_periodic( &manager.pending_restart_handle, NULL, &restart_period, globus_l_gram_process_pending_restarts, &manager); } { globus_reltime_t expire_period; GlobusTimeReltimeSet(expire_period, 1, 0); rc = globus_callback_register_periodic( &manager.expiration_handle, NULL, &expire_period, globus_gram_job_manager_expire_old_jobs, &manager); } { globus_reltime_t lockcheck_period; GlobusTimeReltimeSet(lockcheck_period, 60, 0); rc = globus_callback_register_periodic( &manager.lockcheck_handle, NULL, &lockcheck_period, globus_l_gram_lockcheck, &manager); } { globus_reltime_t idlescript_period; GlobusTimeReltimeSet(idlescript_period, 60, 0); rc = globus_callback_register_periodic( &manager.idle_script_handle, NULL, &idlescript_period, globus_gram_script_close_idle, &manager); } } else if (http_body_fd >= 0) { /* If manager.socket_fd == -1 then we are either the child from the * fork or another process started somehow (either command-line * invocation or via a job submit). If we have a client, then we'll * send our fds to the job manager with the lock and let it process * the job. * * If this succeeds, we set located_active_jm and leave the loop. * Otherwise, we try again. */ if (context_fd >= 0) { rc = globus_gram_job_manager_starter_send( &manager, http_body_fd, context_fd, fileno(stdout), cred); } else { rc = globus_gram_job_manager_starter_send_v2( &manager, cred); } if (rc == GLOBUS_SUCCESS) { located_active_jm = GLOBUS_TRUE; close(http_body_fd); if (context_fd >= 0) { close(context_fd); } manager.done = GLOBUS_TRUE; } else { globus_libc_usleep(250000); } } else { /* We were started by hand, but another process is currently the * main job manager */ unsigned long realpid = 0; FILE * pidin = fopen(manager.pid_path, "r"); fscanf(pidin, "%lu", &realpid); fclose(pidin); fprintf(stderr, "Other job manager process with pid %lu running and processing jobs\n", realpid); exit(0); } } /* Ignore SIGCHILD, and automatically reap child processes. Because of the * fork() above to delegate to another job manager process, and the use of * sub-processes to invoke the perl modules, we create some other * processes. We don't care too much how they exit, so we'll just make sure * we don't create zombies out of them. */ { struct sigaction act; act.sa_handler = SIG_IGN; sigemptyset(&act.sa_mask); sigaddset(&act.sa_mask, SIGCHLD); #ifdef SA_NOCLDWAIT act.sa_flags = SA_NOCLDWAIT; #else /* This may leave zombies running on non-POSIX systems like Hurd */ act.sa_flags = 0; #endif sigaction(SIGCHLD, &act, NULL); } /* Enable log rotation via SIGUSR1 */ { struct sigaction act; act.sa_handler = globus_i_job_manager_log_rotate; sigemptyset(&act.sa_mask); sigaddset(&act.sa_mask, SIGUSR1); act.sa_flags = 0; sigaction(SIGUSR1, &act, NULL); } GlobusGramJobManagerLock(&manager); if (manager.socket_fd != -1 && globus_hashtable_empty(&manager.request_hash) && manager.grace_period_timer == GLOBUS_NULL_HANDLE) { globus_gram_job_manager_set_grace_period_timer(&manager); } /* For the active job manager, this will block until all jobs have * terminated. For any other job manager, the monitor.done is set to * GLOBUS_TRUE and this falls right through. */ while (! manager.done) { GlobusGramJobManagerWait(&manager); } if (manager.expiration_handle != GLOBUS_NULL_HANDLE) { globus_callback_unregister(manager.expiration_handle, NULL, NULL, NULL); } if (manager.lockcheck_handle != GLOBUS_NULL_HANDLE) { globus_callback_unregister(manager.lockcheck_handle, NULL, NULL, NULL); } if (manager.idle_script_handle != GLOBUS_NULL_HANDLE) { globus_callback_unregister(manager.idle_script_handle, NULL, NULL, NULL); } GlobusGramJobManagerUnlock(&manager); globus_gram_job_manager_log( &manager, GLOBUS_GRAM_JOB_MANAGER_LOG_DEBUG, "event=gram.end " "level=DEBUG " "\n"); /* Clean-up to do if we are the active job manager only */ if (manager.socket_fd != -1) { globus_gram_job_manager_script_close_all(&manager); globus_i_gram_usage_end_session_stats(&manager); globus_i_gram_usage_stats_destroy(&manager); remove(manager.pid_path); remove(manager.cred_path); remove(manager.socket_path); remove(manager.lock_path); } globus_gram_job_manager_logging_destroy(); globus_gram_job_manager_destroy(&manager); globus_gram_job_manager_config_destroy(&config); rc = globus_l_gram_deactivate(); if (rc != GLOBUS_SUCCESS) { fprintf(stderr, "deactivation failed with rc=%d\n", rc); exit(1); } /* { const char * gk_jm_id_var = "GATEKEEPER_JM_ID"; const char * gk_jm_id = globus_libc_getenv(gk_jm_id_var); globus_gram_job_manager_request_acct( request, "%s %s JM exiting\n", gk_jm_id_var, gk_jm_id ? gk_jm_id : "none"); } */ return(0); }
/* Test Case: * Submit a job that generates output after a short time. * Before that output is generated, send a STDIO_UPDATE signal, to * direct the output to a different port. * Verify that the output arrives at the new port */ int test_stdio_update(void) { char *old_listener_url, *new_listener_url; char *old_job_contact; int rc; char *callback_contact; char *old_rsl, *new_rsl; test_monitor_t monitor; const char rsl_spec[] = "&(executable=/bin/sh)" "(arguments=-c 'sleep 30; echo hello;')" "(rsl_substitution = (TEST_GASS_URL %s))" "(stdout = $(TEST_GASS_URL)/out)"; const char stdio_update_rsl_spec[] = "&(stdout = %s/out)"; globus_mutex_init(&monitor.mutex, NULL); globus_cond_init(&monitor.cond, NULL); memset(monitor.old_output, 0, sizeof(monitor.old_output)); memset(monitor.new_output, 0, sizeof(monitor.new_output)); monitor.old_request = GLOBUS_NULL_HANDLE; monitor.new_request = GLOBUS_NULL_HANDLE; monitor.status = GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED; monitor.failure_code = 0; /* Create a pair of listeners and get their base URLs. The job will be * submitted with stdout directed to the first, then redirected to the * second via a stdio update signal */ rc = globus_gass_transfer_create_listener( &monitor.old_listener, NULL, "https"); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); test_assert(monitor.old_listener != GLOBUS_NULL_HANDLE); old_listener_url = globus_gass_transfer_listener_get_base_url( monitor.old_listener); test_assert(old_listener_url != NULL); rc = globus_gass_transfer_register_listen( monitor.old_listener, test_l_old_listener_callback, &monitor); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); rc = globus_gass_transfer_create_listener( &monitor.new_listener, NULL, "https"); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); test_assert(monitor.new_listener != GLOBUS_NULL_HANDLE); new_listener_url = globus_gass_transfer_listener_get_base_url( monitor.new_listener); test_assert(new_listener_url != NULL); rc = globus_gass_transfer_register_listen( monitor.new_listener, test_l_new_listener_callback, &monitor); test_assert(rc == GLOBUS_SUCCESS); old_rsl = globus_common_create_string(rsl_spec, old_listener_url); test_assert(old_rsl != NULL); /* Submit the job, do the two-phase commit, then submit a restart * request with the new stdout destination */ rc = globus_gram_client_callback_allow( test_l_gram_callback, &monitor, &callback_contact); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); test_assert(callback_contact != NULL); rc = globus_gram_client_job_request( contact_string, old_rsl, GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED| GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_IN| GLOBUS_GRAM_PROTOCOL_JOB_STATE_PENDING| GLOBUS_GRAM_PROTOCOL_JOB_STATE_ACTIVE| GLOBUS_GRAM_PROTOCOL_JOB_STATE_STAGE_OUT| GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE| GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED, callback_contact, &old_job_contact); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); test_assert(old_job_contact != NULL); globus_mutex_lock(&monitor.mutex); while (monitor.status == GLOBUS_GRAM_PROTOCOL_JOB_STATE_UNSUBMITTED) { globus_cond_wait(&monitor.cond, &monitor.mutex); } new_rsl = globus_common_create_string( stdio_update_rsl_spec, new_listener_url); test_assert(new_rsl != NULL); rc = globus_gram_client_job_signal( old_job_contact, GLOBUS_GRAM_PROTOCOL_JOB_SIGNAL_STDIO_UPDATE, new_rsl, &monitor.status, &monitor.failure_code); test_assert_gram_rc_equals(rc, GLOBUS_SUCCESS); /* Wait for job to complete. After it's done, check to see which * destination got stdout */ while (monitor.status != GLOBUS_GRAM_PROTOCOL_JOB_STATE_DONE && monitor.status != GLOBUS_GRAM_PROTOCOL_JOB_STATE_FAILED) { globus_cond_wait(&monitor.cond, &monitor.mutex); } if (monitor.old_request) { globus_gass_transfer_fail(monitor.old_request, test_l_gass_fail, NULL); } globus_mutex_unlock(&monitor.mutex); if (monitor.new_output[0] == 0) { fprintf(stderr, "Didn't get expected output to new handle\n"); test_assert(strcmp((char *) monitor.new_output, "hello\n") == 0); } if (monitor.old_output[0] != 0) { fprintf(stderr, "Unexpected output to old handle: %s", monitor.old_output); test_assert(monitor.old_output[0] == 0); } return rc; }
/** * Initialize configuration based on command-line arguments * * @param config * LRMA-specific configuration state * @param argc * Count of command-line arguments to the job manager. * @param argv * Array of command-line arguments to the job manager. * * @retval GLOBUS_SUCCESS * Success * @retval GLOBUS_GRAM_PROTOCOL_ERROR_GATEKEEPER_MISCONFIGURED * Command-line includes -help */ int globus_gram_job_manager_config_init( globus_gram_job_manager_config_t * config, int argc, char ** argv) { int i; int rc = 0; char * tmp; char hostname[MAXHOSTNAMELEN]; struct utsname utsname; char * conf_path = NULL; char * dot; char * gatekeeper_contact; memset(config, 0, sizeof(globus_gram_job_manager_config_t)); /* if -conf is passed then get the arguments from the file * specified */ if (argc > 2 && !strcmp(argv[1],"-conf")) { char ** newargv; char * newbuf; int newargc = 52; int length; FILE *fp; newargv = (char**) malloc(newargc * sizeof(char *)); /* not freed */ newargv[0] = argv[0]; /* get file length via fseek & ftell */ if ((fp = fopen(argv[2], "r")) == NULL) { globus_gram_job_manager_log( NULL, GLOBUS_GRAM_JOB_MANAGER_LOG_FATAL, "event=gram.config.end level=FATAL path=\"%s\" " "status=-1 msg=\"%s\" errno=%d reason=\"%s\"\n", argv[2], "Error opening configuration file", errno, strerror(errno)); exit(1); } conf_path = argv[2]; fseek(fp, 0, SEEK_END); length = ftell(fp); if (length <=0) { globus_gram_job_manager_log( NULL, GLOBUS_GRAM_JOB_MANAGER_LOG_FATAL, "event=gram.config.end level=FATAL path=\"%s\" " "status=-1 msg=\"%s\" errno=%d reason=\"%s\"\n", conf_path, "Error determining config file length", errno, strerror(errno)); exit(1); } rewind(fp); newbuf = (char *) malloc(length+1); /* dont free */ i = fread(newbuf, 1, length, fp); if (i < 0) { globus_gram_job_manager_log( NULL, GLOBUS_GRAM_JOB_MANAGER_LOG_FATAL, "event=gram.config.end level=FATAL path=\"%s\" " "status=-1 msg=\"%s\" errno=%d reason=\"%s\"\n", conf_path, "Error reading configuration file", errno, strerror(errno)); exit(1); } newbuf[i] = '\0'; fclose(fp); newargv[0] = argv[0]; newargc--; globus_l_gram_tokenize(newbuf, &newargv[1], &newargc); for (i=3; i<argc; i++) newargv[++newargc] = strdup(argv[i]); argv = newargv; argc = newargc + 1; } /* Default log level if nothing specified on command-line or config file */ config->log_levels = -1; /* Default to using GLOBUS_USAGE_TARGETS environment variable. * If not set, use the Globus usage stats service * Eitehr can be overridden by using -disable-usagestats or setting * -usagestats-targets in the configuration file */ if ((tmp = getenv("GLOBUS_USAGE_TARGETS")) != NULL) { config->usage_targets = strdup(tmp); } else { config->usage_targets = strdup("usage-stats.globus.org:4810"); } /* * Parse the command line arguments */ for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-k") == 0) { config->kerberos = GLOBUS_TRUE; } else if ((strcmp(argv[i], "-home") == 0) && (i + 1 < argc)) { config->globus_location = strdup(argv[++i]); } else if ((strcmp(argv[i], "-target-globus-location") == 0) && (i + 1 < argc)) { config->target_globus_location = strdup(argv[++i]); } else if ((strcmp(argv[i], "-type") == 0) && (i + 1 < argc)) { config->jobmanager_type = strdup(argv[++i]); } else if((strcmp(argv[i], "-history") == 0) && (i + 1 < argc)) { config->job_history_dir = strdup(argv[++i]); } else if (strcmp(argv[i], "-cache-location") == 0) { config->cache_location = strdup(argv[++i]); } else if (strcmp(argv[i], "-scratch-dir-base") == 0) { config->scratch_dir_base = strdup(argv[++i]); } else if ((strcmp(argv[i], "-condor-arch") == 0) && (i + 1 < argc)) { config->condor_arch = strdup(argv[++i]); } else if ((strcmp(argv[i], "-condor-os") == 0) && (i + 1 < argc)) { config->condor_os = strdup(argv[++i]); } else if ((strcmp(argv[i], "-globus-gatekeeper-host") == 0) && (i + 1 < argc)) { config->globus_gatekeeper_host = strdup(argv[++i]); } else if ((strcmp(argv[i], "-globus-gatekeeper-port") == 0) && (i + 1 < argc)) { config->globus_gatekeeper_port = strdup(argv[++i]); } else if ((strcmp(argv[i], "-globus-gatekeeper-subject") == 0) && (i + 1 < argc)) { config->globus_gatekeeper_subject = strdup(argv[++i]); } else if ((strcmp(argv[i], "-globus-host-manufacturer") == 0) && (i + 1 < argc)) { config->globus_host_manufacturer = strdup(argv[++i]); } else if ((strcmp(argv[i], "-globus-host-cputype") == 0) && (i + 1 < argc)) { config->globus_host_cputype = strdup(argv[++i]); } else if ((strcmp(argv[i], "-globus-host-osname") == 0) && (i + 1 < argc)) { config->globus_host_osname = strdup(argv[++i]); } else if ((strcmp(argv[i], "-globus-host-osversion") == 0) && (i + 1 < argc)) { config->globus_host_osversion = strdup(argv[++i]); } else if ((strcmp(argv[i], "-globus-tcp-port-range") == 0) && (i + 1 < argc)) { config->tcp_port_range = strdup(argv[++i]); } else if ((strcmp(argv[i], "-globus-tcp-source-range") == 0) && (i + 1 < argc)) { config->tcp_source_range = strdup(argv[++i]); } else if ((strcmp(argv[i], "-state-file-dir") == 0) && (i + 1 < argc)) { config->job_state_file_dir = strdup(argv[++i]); } else if ((strcmp(argv[i], "-x509-cert-dir") == 0) && (i + 1 < argc)) { config->x509_cert_dir = strdup(argv[++i]); } else if ((strcmp(argv[i], "-extra-envvars") == 0) && (i + 1 < argc)) { char * extra_envvars = strdup(argv[++i]); char *p, *q; p = extra_envvars; while (p && *p) { q = strchr(p, ','); if (q) { *q = 0; } globus_list_insert( &config->extra_envvars, strdup(p)); if (q) { p = q+1; } else { p = q; } } free(extra_envvars); } else if ((strcasecmp(argv[i], "-seg-module" ) == 0) && (i + 1 < argc)) { config->seg_module = strdup(argv[++i]); } else if ((strcmp(argv[i], "-audit-directory") == 0) && (i+1 < argc)) { globus_eval_path(argv[++i], &config->auditing_dir); } else if ((strcmp(argv[i], "-globus-toolkit-version") == 0) && (i+1 < argc)) { config->globus_version = strdup(argv[++i]); } else if (strcmp(argv[i], "-disable-streaming") == 0) { /* Ignore this request, as we don't do streaming any more */ config->streaming_disabled = GLOBUS_FALSE; } else if (strcmp(argv[i], "-service-tag") == 0 && (i+1 < argc)) { config->service_tag = strdup(argv[++i]); } else if (strcmp(argv[i], "-enable-syslog") == 0) { config->syslog_enabled = GLOBUS_TRUE; } else if (strcmp(argv[i], "-stdio-log") == 0 && (i+1 < argc)) { /* Backward-compatible definition of -stdio-log based on * -log-pattern implementation */ config->log_pattern = globus_common_create_string( "%s/gram_$(DATE).log", argv[++i]); } else if (strcmp(argv[i], "-log-pattern") == 0 && (i+1 < argc)) { config->log_pattern = strdup(argv[++i]); } else if ((strcmp(argv[i], "-globus-job-dir") == 0) && (i + 1 < argc)) { config->job_dir_home = globus_common_create_string( "%s/%s", argv[++i], strdup(getenv("USER"))); if (config->job_dir_home == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto out; } globus_gram_job_manager_log( NULL, GLOBUS_GRAM_JOB_MANAGER_LOG_TRACE, "event=gram.config.info " "level=TRACE " "option=\"-globus-job-dir\" " "path=\"%s\" " "\n", config->job_dir_home); } else if (strcmp(argv[i], "-log-levels") == 0 && (i+1 < argc)) { rc = globus_i_gram_parse_log_levels( argv[++i], &config->log_levels, NULL); } else if (strcmp(argv[i], "-disable-usagestats") == 0) { config->usage_disabled = GLOBUS_TRUE; } else if (strcmp(argv[i], "-usagestats-targets") == 0 && (i+1 < argc)) { if (config->usage_targets) { free(config->usage_targets); config->usage_targets = NULL; } config->usage_targets = strdup(argv[++i]); } else if (strcmp(argv[i], "-enable-callout") == 0) { config->enable_callout = GLOBUS_TRUE; } else if ((strcasecmp(argv[i], "-help" ) == 0) || (strcasecmp(argv[i], "--help") == 0)) { fprintf(stderr, "Usage: globus-gram-jobmanager\n" "\n" "Required Arguments:\n" "\t-type jobmanager type, i.e. fork, lsf ...\n" "\t-globus-host-manufacturer manufacturer\n" "\t-globus-host-cputype cputype\n" "\t-globus-host-osname osname\n" "\t-globus-host-osversion osversion\n" "\t-globus-gatekeeper-host host\n" "\t-globus-gatekeeper-port port\n" "\t-globus-gatekeeper-subject subject\n" "\n" "Options:\n" "\t-home globus_location\n" "\t-target-globus-location globus_location\n" "\t-condor-arch arch, i.e. SUN4x\n" "\t-condor-os os, i.e. SOLARIS26\n" "\t-history job-history-directory\n" "\t-scratch-dir-base scratch-directory\n" "\t-enable-syslog\n" "\t-stdio-log DIRECTORY\n" "\t-log-levels TRACE|INFO|DEBUG|WARN|ERROR|FATAL\n" "\t-state-file-dir state-directory\n" "\t-globus-tcp-port-range <min port #>,<max port #>\n" "\t-globus-tcp-source-range <min port #>,<max port #>\n" "\t-x509-cert-dir DIRECTORY\n" "\t-cache-location PATH\n" "\t-k\n" "\t-extra-envvars VAR1,VAR2,...\n" "\t-seg-module SEG-MODULE\n" "\t-audit-directory DIRECTORY\n" "\t-globus-toolkit-version VERSION\n" "\t-usagestats-targets <host:port>[!<default | all>],...\n" "\t-enable-callout\n" "\t-globus-job-dir DIRECTORY\n" "\n" "Note: if type=condor then\n" " -condor-os & -condor-arch are required.\n" "\n"); rc = GLOBUS_GRAM_PROTOCOL_ERROR_GATEKEEPER_MISCONFIGURED; goto out; } else { globus_gram_job_manager_log( NULL, GLOBUS_GRAM_JOB_MANAGER_LOG_ERROR, "event=gram.config level=ERROR path=\"%s\" " "argument=%s reason=\"Invalid command-line option\"\n", conf_path ? conf_path : "ARGV", argv[i] ? argv[i] : ""); } } /* If log levels were not specified on the command-line or configuration, set the * service default */ if (config->log_levels == -1) { config->log_levels = 0; } /* Always have these at a minimum */ config->log_levels |= GLOBUS_GRAM_JOB_MANAGER_LOG_FATAL | GLOBUS_GRAM_JOB_MANAGER_LOG_ERROR; /* Verify that required values are present */ if(config->jobmanager_type == NULL) { globus_gram_job_manager_log( NULL, GLOBUS_GRAM_JOB_MANAGER_LOG_ERROR, "event=gram.config level=ERROR path=\"%s\" argument=\"-type\" reason=\"Missing -type command-line option\"\n", conf_path ? conf_path : "ARGV"); rc = GLOBUS_GRAM_PROTOCOL_ERROR_GATEKEEPER_MISCONFIGURED; goto out; } if(config->home == NULL) { config->home = strdup(getenv("HOME")); if (config->home == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto out; } } if (config->service_tag == NULL) { config->service_tag = strdup("untagged"); } if (config->tcp_port_range == NULL) { char * ev = getenv("GLOBUS_TCP_PORT_RANGE"); if (ev != NULL) { config->tcp_port_range = strdup(ev); } } if (config->tcp_source_range == NULL) { char * ev = getenv("GLOBUS_TCP_SOURCE_RANGE"); if (ev != NULL) { config->tcp_source_range = strdup(ev); } } if (! globus_list_search_pred( config->extra_envvars, globus_l_env_present, "PATH")) { char * path = strdup("PATH"); if (!path) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto out; } globus_list_insert(&config->extra_envvars, path); } /* Now initialize values from our environment */ config->logname = strdup(getenv("LOGNAME")); if (config->logname == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto out; } if (config->globus_location == NULL) { rc = globus_location(&config->globus_location); if (rc != GLOBUS_SUCCESS) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto out; } } if (config->target_globus_location == NULL) { config->target_globus_location = strdup(config->globus_location); if (config->target_globus_location == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto out; } } if (config->job_state_file_dir == NULL) { rc = globus_eval_path("${localstatedir}/lib/globus/gram_job_state", &config->job_state_file_dir); if (rc != 0 || config->job_state_file_dir == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto out; } } if (config->job_dir_home == NULL) { config->job_dir_home = globus_common_create_string("%s/%s", config->job_state_file_dir, config->logname); if (config->job_dir_home == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto out; } } if (config->scratch_dir_base == NULL) { config->scratch_dir_base = strdup( config->home); if (config->scratch_dir_base == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto out; } } rc = globus_libc_gethostname(hostname, sizeof(hostname)); if (rc != GLOBUS_SUCCESS) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto out; } config->hostname = strdup(hostname); if (config->hostname == GLOBUS_NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto out; } config->short_hostname = strdup(hostname); dot = strchr(config->short_hostname, '.'); if (dot != NULL) { *dot = 0; } rc = uname(&utsname); if (rc >= 0) { if (config->globus_host_osname == NULL) { config->globus_host_osname = strdup(utsname.sysname); } if (config->globus_host_osversion == NULL) { if (strcmp(utsname.sysname, "AIX") == 0) { config->globus_host_osversion = globus_common_create_string( "%s.%s", utsname.version, utsname.release); } else { config->globus_host_osversion = globus_common_create_string( "%s", utsname.release); } } } gatekeeper_contact = getenv("GLOBUS_GATEKEEPER_CONTACT_STRING"); if (gatekeeper_contact) { char *colon; char *save = strdup(gatekeeper_contact); gatekeeper_contact = save; if (gatekeeper_contact) { colon = strchr(gatekeeper_contact, ':'); if (colon) { if (!config->globus_gatekeeper_host) { *colon = '\0'; config->globus_gatekeeper_host = strdup(gatekeeper_contact); } gatekeeper_contact = colon + 1; colon = strchr(gatekeeper_contact, ':'); if (colon) { if (!config->globus_gatekeeper_port) { *colon = '\0'; config->globus_gatekeeper_port = strdup(gatekeeper_contact); } gatekeeper_contact = colon + 1; if (!config->globus_gatekeeper_subject) { config->globus_gatekeeper_subject = strdup(gatekeeper_contact); } } } } free(save); } rc = globus_module_activate(GLOBUS_GSI_GSSAPI_MODULE); if (rc != GLOBUS_SUCCESS) { goto out; } rc = globus_gram_job_manager_gsi_get_subject(&config->subject); if (rc != GLOBUS_SUCCESS) { goto out; } config->proxy_timeout = 10*60; out: return rc; }
static globus_result_t globus_l_extension_dlopen( const char * name, lt_dlhandle * handle) { char library[1024]; lt_dlhandle dlhandle; char * path; char * basename; char * search_path = NULL; char * save_path = NULL; globus_result_t result = GLOBUS_SUCCESS; GlobusFuncName(globus_l_extension_dlopen); path = globus_libc_strdup(name); if(path && (basename = strrchr(path, '/'))) { *basename = 0; if(basename == path) { /* ignore root dir */ name = path + 1; } else if(*(basename + 1) == 0) { /* ignore trailing slashes */ name = path; } else { name = basename + 1; if(globus_l_globus_location) { /* if globus_location is not set, then it's likely I won't * find the library */ search_path = globus_common_create_string( "%s/%s", globus_l_globus_location, path); } } } globus_l_libtool_mutex_lock(); if(search_path || globus_l_globus_location) { if((save_path = (char *) lt_dlgetsearchpath())) { /* libtool frees this pointer before setting the next one */ save_path = globus_libc_strdup(save_path); } lt_dlsetsearchpath( search_path ? search_path : globus_l_globus_location); } snprintf(library, 1024, "lib%s", name); library[1023] = 0; dlhandle = lt_dlopenext(library); if(!dlhandle) { /* older libtools dont search the extensions correctly */ snprintf(library, 1024, "lib%s" MY_LIB_EXT, name); library[1023] = 0; dlhandle = lt_dlopenext(library); } #if USE_SYMBOL_LABELS if (!dlhandle) { snprintf(library, 1024, "lib%s_%s", name, (sizeof(long) == 8) ? "gcc64pthr" : "gcc32pthr"); library[1023] = 0; dlhandle = lt_dlopenext(library); if(!dlhandle) { /* older libtools dont search the extensions correctly */ snprintf(library, 1024, "lib%s_%s" MY_LIB_EXT, name, (sizeof(long) == 8) ? "gcc64pthr" : "gcc32pthr"); library[1023] = 0; dlhandle = lt_dlopenext(library); } } #endif if(!dlhandle) { const char * error; error = lt_dlerror(); GlobusExtensionDebugPrintf( GLOBUS_L_EXTENSION_DEBUG_DLL, (_GCSL("[%s] Couldn't dlopen %s in %s (or LD_LIBRARY_PATH): %s\n"), _globus_func_name, library, search_path ? search_path : globus_l_globus_location ? globus_l_globus_location : "(default)", error ? error : "(null)")); result = globus_error_put( globus_error_construct_error( GLOBUS_EXTENSION_MODULE, NULL, GLOBUS_EXTENSION_ERROR_OPEN_FAILED, __FILE__, _globus_func_name, __LINE__, "Couldn't dlopen %s in %s (or LD_LIBRARY_PATH): %s\n", library, (search_path ? search_path : (globus_l_globus_location ? globus_l_globus_location : "(default)")), error ? error : "(null)")); } if(search_path || globus_l_globus_location) { lt_dlsetsearchpath(save_path); if(save_path) { globus_free(save_path); } } globus_l_libtool_mutex_unlock(); if(search_path) { globus_free(search_path); } if(path) { globus_free(path); } *handle = dlhandle; return result; }
/* * Timeout test: * -t server|client * Configure the server or client to cause a timeout. If server is * selected, then it will delay its part of the operation longer than the * timeout value, causing the client to time out (and vice versa). * -T timeout-in-ms * Set the timeout value in ms * -a * Expect / cause the accept operation to delay longer than the timeout. * -r * Expect / cause a read operation to delay longer than the timeout. * */ int main( int argc, char * argv[]) { int rc; char * contact = NULL; globus_result_t result; globus_l_timeout_info_t client_timeout_info; globus_l_timeout_info_t server_timeout_info; globus_reltime_t timeout; client_timeout_info.cause_timeout = GLOBUS_TRUE; client_timeout_info.expect_timeout = GLOBUS_FALSE; server_timeout_info.cause_timeout = GLOBUS_FALSE; server_timeout_info.expect_timeout = GLOBUS_TRUE; client_timeout_info.timeout_state = GLOBUS_XIO_OPERATION_TYPE_ACCEPT; server_timeout_info.timeout_state = GLOBUS_XIO_OPERATION_TYPE_ACCEPT; client_timeout_info.timeout = 1000; server_timeout_info.timeout = 1000; while ((rc = getopt(argc, argv, "t:T:arh")) != EOF) { switch (rc) { case 'h': usage(argv[0]); exit(0); case 't': if (strcmp(optarg, "client") == 0) { client_timeout_info.cause_timeout = GLOBUS_TRUE; client_timeout_info.expect_timeout = GLOBUS_FALSE; server_timeout_info.cause_timeout = GLOBUS_FALSE; server_timeout_info.expect_timeout = GLOBUS_TRUE; } else if (strcmp(optarg, "server") == 0) { client_timeout_info.cause_timeout = GLOBUS_FALSE; client_timeout_info.expect_timeout = GLOBUS_TRUE; server_timeout_info.cause_timeout = GLOBUS_TRUE; server_timeout_info.expect_timeout = GLOBUS_FALSE; } else { usage(argv[0]); exit(1); } break; case 'T': client_timeout_info.timeout = atoi(optarg); server_timeout_info.timeout = atoi(optarg); break; case 'a': client_timeout_info.timeout_state = GLOBUS_XIO_OPERATION_TYPE_ACCEPT; server_timeout_info.timeout_state = GLOBUS_XIO_OPERATION_TYPE_ACCEPT; break; case 'r': client_timeout_info.timeout_state = GLOBUS_XIO_OPERATION_TYPE_READ; server_timeout_info.timeout_state = GLOBUS_XIO_OPERATION_TYPE_READ; break; default: usage(argv[0]); exit(1); } } rc = http_test_initialize( &globus_l_tcp_driver, &globus_l_http_driver, &globus_l_http_stack); if (rc != GLOBUS_SUCCESS) { exit(2); } globus_mutex_init(&lock, NULL); globus_cond_init(&cond, NULL); GlobusTimeReltimeSet(timeout, 0, (server_timeout_info.timeout * 1000)); globus_xio_attr_init(&client_timeout_info.attr); globus_xio_attr_init(&server_timeout_info.attr); switch (server_timeout_info.timeout_state) { case GLOBUS_XIO_OPERATION_TYPE_ACCEPT: if (client_timeout_info.cause_timeout) { globus_xio_attr_cntl( server_timeout_info.attr, NULL, GLOBUS_XIO_ATTR_SET_TIMEOUT_ACCEPT, globus_l_timeout_callback, &timeout, NULL); } else { fprintf(stderr, "Unable to handle server-caused accept timeout\n"); exit(6); } break; case GLOBUS_XIO_OPERATION_TYPE_READ: if (client_timeout_info.cause_timeout) { globus_xio_attr_cntl( server_timeout_info.attr, NULL, GLOBUS_XIO_ATTR_SET_TIMEOUT_READ, globus_l_timeout_callback, &timeout, NULL); } else { globus_xio_attr_cntl( client_timeout_info.attr, NULL, GLOBUS_XIO_ATTR_SET_TIMEOUT_READ, globus_l_timeout_callback, &timeout, NULL); } break; default: fprintf(stderr, "Error: invalid timeout state\n"); exit(3); } /* Set up client attributes */ globus_xio_attr_cntl( client_timeout_info.attr, globus_l_http_driver, GLOBUS_XIO_HTTP_ATTR_SET_REQUEST_METHOD, "POST"); /* Modulate timeout state to causer's related state for delaying */ if (client_timeout_info.cause_timeout) { switch (client_timeout_info.timeout_state) { case GLOBUS_XIO_OPERATION_TYPE_ACCEPT: client_timeout_info.timeout_state = GLOBUS_XIO_OPERATION_TYPE_OPEN; break; case GLOBUS_XIO_OPERATION_TYPE_READ: client_timeout_info.timeout_state = GLOBUS_XIO_OPERATION_TYPE_WRITE; break; case GLOBUS_XIO_OPERATION_TYPE_WRITE: case GLOBUS_XIO_OPERATION_TYPE_OPEN: case GLOBUS_XIO_OPERATION_TYPE_CLOSE: case GLOBUS_XIO_OPERATION_TYPE_FINISHED: case GLOBUS_XIO_OPERATION_TYPE_NONE: case GLOBUS_XIO_OPERATION_TYPE_DRIVER: case GLOBUS_XIO_OPERATION_TYPE_DD: case GLOBUS_XIO_OPERATION_TYPE_SERVER_INIT: fprintf(stderr, "Error: unexpected state: %d\n", client_timeout_info.state); exit(4); } } else { globus_assert(server_timeout_info.cause_timeout); switch (server_timeout_info.timeout_state) { case GLOBUS_XIO_OPERATION_TYPE_ACCEPT: fprintf(stderr, "Invalid option (server-caused accept timeout)\n"); exit(5); case GLOBUS_XIO_OPERATION_TYPE_READ: server_timeout_info.timeout_state = GLOBUS_XIO_OPERATION_TYPE_WRITE; break; case GLOBUS_XIO_OPERATION_TYPE_WRITE: case GLOBUS_XIO_OPERATION_TYPE_OPEN: case GLOBUS_XIO_OPERATION_TYPE_CLOSE: case GLOBUS_XIO_OPERATION_TYPE_FINISHED: case GLOBUS_XIO_OPERATION_TYPE_NONE: case GLOBUS_XIO_OPERATION_TYPE_DRIVER: case GLOBUS_XIO_OPERATION_TYPE_DD: case GLOBUS_XIO_OPERATION_TYPE_SERVER_INIT: fprintf(stderr, "Error: unexpected state: %d\n", server_timeout_info.state); exit(4); } } /* create server */ server_timeout_info.state = GLOBUS_XIO_OPERATION_TYPE_ACCEPT; server_timeout_info.handle = NULL; server_timeout_info.result = GLOBUS_SUCCESS; server_timeout_info.contact = NULL; result = globus_xio_server_create( &server_timeout_info.server, server_timeout_info.attr, globus_l_http_stack); result = globus_xio_server_get_contact_string( server_timeout_info.server, &contact); client_timeout_info.contact = globus_common_create_string("http://%s/%s", contact, "ok"); /* create client handle */ client_timeout_info.state = GLOBUS_XIO_OPERATION_TYPE_OPEN; client_timeout_info.handle = NULL; client_timeout_info.result = GLOBUS_SUCCESS; client_timeout_info.server = NULL; result = globus_xio_handle_create( &client_timeout_info.handle, globus_l_http_stack); /* oneshot to start server state machine */ result = globus_callback_register_oneshot( NULL, &globus_i_reltime_zero, state_machine, &server_timeout_info); /* oneshot to start client state machine */ result = globus_callback_register_oneshot( NULL, &globus_i_reltime_zero, state_machine, &client_timeout_info); /* wait for both state machines to terminate */ globus_mutex_lock(&lock); while (client_timeout_info.state != GLOBUS_XIO_OPERATION_TYPE_NONE && server_timeout_info.state != GLOBUS_XIO_OPERATION_TYPE_NONE) { globus_cond_wait(&cond, &lock); } globus_mutex_unlock(&lock); globus_mutex_destroy(&lock); globus_module_deactivate_all(); return (client_timeout_info.result || server_timeout_info.result || client_timeout_info.expect_timeout || server_timeout_info.expect_timeout); }
/** * Periodic poll of file to act like tail -f * * @param user_arg * Log file parsing state */ static void globus_l_job_manager_poll_callback( void * user_arg) { int rc; globus_l_job_manager_logfile_state_t * state = user_arg; globus_bool_t eof_hit = GLOBUS_FALSE; globus_reltime_t delay; globus_result_t result; time_t poll_time = time(NULL); struct tm poll_tm, *tm_result; struct stat stat; char * today; SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_INFO, ("globus_l_job_manager_poll_callback()\n")); globus_mutex_lock(&globus_l_job_manager_mutex); if (shutdown_called) { SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_INFO, ("polling while deactivating")); globus_mutex_unlock(&globus_l_job_manager_mutex); goto error; } globus_mutex_unlock(&globus_l_job_manager_mutex); if (state->fp != NULL) { /* Parse data */ SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_TRACE, ("parsing events\n")); rc = globus_l_job_manager_parse_events(state); if (rc == SEG_JOB_MANAGER_ERROR_LOG_EOF) { eof_hit = GLOBUS_TRUE; } } if (eof_hit) { tm_result = globus_libc_gmtime_r(&poll_time, &poll_tm); if (tm_result == NULL) { SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_WARN, ("Couldn't convert to gmtime\n")); } else { today = globus_common_create_string( "%s/%4d%02d%02d", state->log_dir, tm_result->tm_year+1900, tm_result->tm_mon+1, tm_result->tm_mday); if (today && (strcmp(today, state->path) != 0)) { /* New day... if new file exists and the old one hasn't changed since our * last poll, mark it as old */ if (globus_l_next_file_exists(state)) { rc = fstat(fileno(state->fp), &stat); if (rc != -1) { if (ftello(state->fp) == stat.st_size) { state->old_log = GLOBUS_TRUE; } } } } if (today) { free(today); } } } /* If end of log, close this logfile and look for a new one. Also, if * the current day's log doesn't exist yet, check for it */ if ((eof_hit && state->old_log) || state->fp == NULL) { if (state->fp) { fclose(state->fp); state->fp = NULL; state->start_timestamp.tm_mday++; state->start_timestamp.tm_hour = 0; state->start_timestamp.tm_min = 0; state->start_timestamp.tm_sec = 0; globus_l_job_manager_normalize_date(&state->start_timestamp); } rc = globus_l_job_manager_find_logfile(state); if (rc == GLOBUS_SUCCESS) { /* Opening a new logfile, run w/out delay */ state->fp = fopen(state->path, "r"); if (state->fp == NULL) { goto error; } eof_hit = GLOBUS_FALSE; GlobusTimeReltimeSet(delay, 0, 0); } else if (rc == SEG_JOB_MANAGER_ERROR_LOG_NOT_PRESENT) { /* Current day's logfile not present, wait a bit longer for * it to show up */ GlobusTimeReltimeSet(delay, 30, 0); eof_hit = GLOBUS_TRUE; } else { goto error; } } else if(eof_hit) { /* eof on current logfile, wait for new data */ GlobusTimeReltimeSet(delay, 2, 0); } else { /* still data available in current file, hurry up! */ GlobusTimeReltimeSet(delay, 0, 0); } result = globus_callback_register_oneshot( &state->callback, &delay, globus_l_job_manager_poll_callback, state); if (result != GLOBUS_SUCCESS) { goto error; } SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_INFO, ("globus_l_job_manager_poll_callback() exited with/success\n")); return; error: globus_mutex_lock(&globus_l_job_manager_mutex); if (shutdown_called) { callback_count--; if (callback_count == 0) { globus_cond_signal(&globus_l_job_manager_cond); } } globus_mutex_unlock(&globus_l_job_manager_mutex); SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_WARN, ("globus_l_job_manager_poll_callback() exited with/error\n")); return; }
/* driver list stuff */ globus_result_t globus_xio_driver_list_from_string( char * driver_string, globus_list_t ** driver_list, globus_hashtable_t * safe_table) { globus_result_t result; globus_bool_t done = GLOBUS_FALSE; globus_bool_t loaded; char * opts; char * ptr; char * driver_str; char * driver_name; char * tmp_str; globus_xio_driver_t driver; globus_list_t * list = NULL; globus_xio_driver_list_ent_t * list_ent; GlobusXIOName(globus_xio_driver_list_from_string); *driver_list = NULL; if(driver_string == NULL) { result = GlobusXIOErrorParameter("driver_string"); goto error_param; } driver_str = globus_libc_strdup(driver_string); tmp_str = driver_str; while(!done) { loaded = GLOBUS_FALSE; driver_name = tmp_str; ptr = strchr(driver_name, ','); if(ptr != NULL) { *ptr = '\0'; tmp_str = ptr+1; } else { done = GLOBUS_TRUE; } opts = strchr(driver_name, ':'); if(opts != NULL) { *opts = '\0'; opts++; /* decode the string */ globus_url_string_hex_decode(opts); } /* check against the safe list */ if(safe_table != NULL) { char * err_str; list_ent = (globus_xio_driver_list_ent_t *) globus_hashtable_lookup(safe_table, driver_name); if(list_ent == NULL) { err_str = globus_common_create_string( "%s driver not whitelisted", driver_name); result = GlobusXIOErrorParameter(err_str); globus_free(err_str); goto error_load; } driver = list_ent->driver; } else { result = globus_xio_driver_load(driver_name, &driver); if(result != GLOBUS_SUCCESS) { goto error_load; } loaded = GLOBUS_TRUE; } list_ent = (globus_xio_driver_list_ent_t *) globus_calloc(1, sizeof(globus_xio_driver_list_ent_t)); list_ent->opts = globus_libc_strdup(opts); list_ent->driver = driver; list_ent->driver_name = globus_libc_strdup(driver_name); list_ent->loaded = loaded; globus_list_insert(&list, list_ent); } globus_free(driver_str); /* reverse list */ while(!globus_list_empty(list)) { globus_list_insert(driver_list, globus_list_first(list)); globus_list_remove(&list, list); } return GLOBUS_SUCCESS; error_load: globus_free(driver_str); while(!globus_list_empty(list)) { list_ent = (globus_xio_driver_list_ent_t *) globus_list_remove(&list, list); if(list_ent->loaded) { globus_xio_driver_unload(list_ent->driver); } globus_free(list_ent->driver_name); if(list_ent->opts != NULL) { globus_free(list_ent->opts); } globus_free(list_ent); } error_param: return result; }
* ************************************************************************/ static void globus_l_dsi_rest_recv( globus_gfs_operation_t op, globus_gfs_transfer_info_t * transfer_info, void * user_arg) { globus_dsi_rest_gridftp_op_arg_t gridftp_op_arg = {.op=op}; globus_l_dsi_rest_handle_t *dsi_rest_handle = user_arg; char *uri; globus_result_t result = GLOBUS_SUCCESS; uri = globus_common_create_string( "http://%s/%s", dsi_rest_handle->contact_string, transfer_info->pathname+1); if (uri == NULL) { result = GlobusGFSErrorMemory("globus_common_create_string"); goto create_uri_fail; } globus_gridftp_server_begin_transfer(op, 0, NULL); do { globus_gridftp_server_get_write_range( gridftp_op_arg.op, &gridftp_op_arg.offset, &gridftp_op_arg.length);
size_t globus_i_dsi_rest_header( char *buffer, size_t size, size_t nitems, void *callback_arg) { globus_result_t result = GLOBUS_SUCCESS; size_t total = size * nitems; globus_i_dsi_rest_request_t *request = callback_arg; GlobusDsiRestEnter(); if (request->response_code == 0 && request->response_reason[0] == 0) { /* Actually the status line, not a header */ char bufferstring[total + 1]; memcpy(bufferstring, buffer, total); bufferstring[total] = 0; GlobusDsiRestInfo("%s", buffer); int scans = sscanf(bufferstring, "HTTP/%*s %d %64[^\r]", &request->response_code, request->response_reason); if (scans != 2) { result = GlobusDsiRestErrorParse(bufferstring); } goto done; } else { GlobusDsiRestDebug("%.*s", (int) (size*nitems), buffer); } if (request->response_callback == NULL && request->read_part.data_read_callback != globus_dsi_rest_read_multipart) { /* Don't bother parsing if client doesn't care */ goto done; } result = globus_i_dsi_rest_header_parse( &request->read_part.headers, buffer, total); if (result != GLOBUS_SUCCESS) { if (request->result == GLOBUS_SUCCESS) { request->result = result; } goto done; } if (memcmp(buffer, "\r\n", 2) == 0) { if (request->response_code == 100) { /* If we get a 100 Continue response, we'll need to reinitialize * the headers and response code for the real response */ request->response_code = 0; request->response_reason[0] = 0; for (size_t i = 0; i < request->read_part.headers.count; i++) { free((char *) request->read_part.headers.key_value[i].key); free((char *) request->read_part.headers.key_value[i].value); } free(request->read_part.headers.key_value); request->read_part.headers.key_value = NULL; request->read_part.headers.count = 0; } else { globus_dsi_rest_response_arg_t *response = request->response_callback_arg; if (request->response_callback == globus_dsi_rest_response) { response->request_bytes_uploaded = request->request_bytes_uploaded; response->response_bytes_downloaded = request->response_bytes_downloaded; } if (request->read_part.data_read_callback == globus_dsi_rest_read_multipart) { const char *boundary = NULL; const char *boundary_end = NULL; globus_i_dsi_rest_read_multipart_arg_t *read_multipart = request->read_part.data_read_callback_arg; for (size_t i = 0; i < request->read_part.headers.count; i++) { if (strcasecmp( request->read_part.headers.key_value[i].key, "Content-Type") == 0 && strncasecmp( request->read_part.headers.key_value[i].value, "multipart/", strlen("multipart/")) == 0) { boundary = strcasestr( request->read_part.headers.key_value[i].value, "boundary="); boundary += strlen("boundary="); if (*boundary == '"') { boundary++; for (size_t b = 0; boundary[b] != 0; b++) { if (boundary[b] == '"') { boundary_end = &boundary[b-1]; } if (boundary[b] == '\\') { b++; } } } else { for (size_t b = 0; boundary[b] != 0; b++) { if (isspace(boundary[b])) { boundary_end = &boundary[b-1]; break; } } } } } if (boundary != NULL) { if (boundary_end != NULL) { read_multipart->boundary = globus_common_create_string( "%.*s", (int) (boundary_end - boundary), boundary); } else { read_multipart->boundary = globus_common_create_string( "%s", boundary); } read_multipart->boundary_length = strlen( read_multipart->boundary); /* \r\n--boundary--\r\n\0 */ read_multipart->boundary_buffer_length = read_multipart->boundary_length + 9; read_multipart->boundary_buffer = malloc( read_multipart->boundary_buffer_length); read_multipart->boundary_buffer_offset = 0; } } if (request->response_callback != NULL) { result = request->response_callback( request->response_callback_arg, request->response_code, request->response_reason, &request->read_part.headers); } } } done: if (result != GLOBUS_SUCCESS) { total = !total; } GlobusDsiRestExitSizeT(total); return total; }
/** * @brief Export a GSSAPI credential * @ingroup globus_gsi_gssapi_extensions * @details * Saves the credential so it can be checkpointed and * imported by gss_import_cred * * @param minor_status * @param cred_handle * @param desired_mech * Should either be gss_mech_globus_gssapi_openssl or * NULL (in which case gss_mech_globus_gssapi_openssl is * assumed). * @param option_req * @param export_buffer * * @return */ OM_uint32 GSS_CALLCONV gss_export_cred( OM_uint32 * minor_status, const gss_cred_id_t cred_handle, const gss_OID desired_mech, OM_uint32 option_req, gss_buffer_t export_buffer) { OM_uint32 major_status = GLOBUS_SUCCESS; BIO * bp = NULL; gss_cred_id_desc * cred_desc = NULL; globus_result_t local_result; char * proxy_filename = NULL; GLOBUS_I_GSI_GSSAPI_DEBUG_ENTER; cred_desc = (gss_cred_id_desc *) cred_handle; *minor_status = (OM_uint32) GLOBUS_SUCCESS; if (export_buffer == NULL || export_buffer == GSS_C_NO_BUFFER) { major_status = GSS_S_FAILURE; GLOBUS_GSI_GSSAPI_ERROR_RESULT( minor_status, GLOBUS_GSI_GSSAPI_ERROR_BAD_ARGUMENT, (_GGSL("NULL or empty export_buffer parameter passed to function: %s"), __func__)); goto exit; } export_buffer->length = 0; export_buffer->value = NULL; if (cred_handle == NULL) { major_status = GSS_S_FAILURE; GLOBUS_GSI_GSSAPI_ERROR_RESULT( minor_status, GLOBUS_GSI_GSSAPI_ERROR_BAD_ARGUMENT, (_GGSL("NULL or empty export_buffer parameter passed to function: %s"), __func__)); goto exit; } if(desired_mech != NULL && g_OID_equal(desired_mech, (gss_OID) gss_mech_globus_gssapi_openssl)) { major_status = GSS_S_BAD_MECH; GLOBUS_GSI_GSSAPI_ERROR_RESULT( minor_status, GLOBUS_GSI_GSSAPI_ERROR_BAD_MECH, (_GGSL("The desired mechanism of: %s, is not supported by this " "GSS implementation"), desired_mech->elements)); goto exit; } if(option_req == GSS_IMPEXP_OPAQUE_FORM) { /* When option_req is equal to EXPORT_OPAQUE_FORM (0), it exports * an opaque buffer suitable for storage in memory or on * disk or passing to another process, which * can import the buffer with gss_import_cred(). */ bp = BIO_new(BIO_s_mem()); if(bp == NULL) { GLOBUS_GSI_GSSAPI_OPENSSL_ERROR_RESULT( minor_status, GLOBUS_GSI_GSSAPI_ERROR_WITH_OPENSSL, (_GGSL("Couldn't initialize IO bio for exporting credential"))); major_status = GSS_S_FAILURE; goto exit; } local_result = globus_gsi_cred_write(cred_desc->cred_handle, bp); if(local_result != GLOBUS_SUCCESS) { GLOBUS_GSI_GSSAPI_ERROR_CHAIN_RESULT( minor_status, local_result, GLOBUS_GSI_GSSAPI_ERROR_IMPEXP_BIO_SSL); major_status = GSS_S_FAILURE; goto exit; } export_buffer->length = BIO_pending(bp); if (export_buffer->length > 0) { export_buffer->value = (char *) malloc(export_buffer->length); if (export_buffer->value == NULL) { export_buffer->length = 0; GLOBUS_GSI_GSSAPI_MALLOC_ERROR(minor_status); major_status = GSS_S_FAILURE; goto exit; } BIO_read(bp, export_buffer->value, export_buffer->length); } else { export_buffer->value = NULL; } major_status = GSS_S_COMPLETE; } else if(option_req == GSS_IMPEXP_MECH_SPECIFIC) { /* With option_req is equal to EXPORT_MECH_SPECIFIC (1), * it exports a buffer filled with mechanism-specific * information that the calling application can use * to pass the credentials to another process that * is not written to the GSS-API. */ local_result = GLOBUS_GSI_SYSCONFIG_GET_UNIQUE_PROXY_FILENAME(&proxy_filename); if(local_result != GLOBUS_SUCCESS) { proxy_filename = NULL; GLOBUS_GSI_GSSAPI_ERROR_CHAIN_RESULT( minor_status, local_result, GLOBUS_GSI_GSSAPI_ERROR_WITH_GSI_PROXY); major_status = GSS_S_FAILURE; goto exit; } GLOBUS_I_GSI_GSSAPI_DEBUG_FPRINTF( 3, (globus_i_gsi_gssapi_debug_fstream, "Writing exported cred to: %s\n", proxy_filename)); local_result = globus_gsi_cred_write_proxy(cred_desc->cred_handle, proxy_filename); if(local_result != GLOBUS_SUCCESS) { GLOBUS_GSI_GSSAPI_ERROR_CHAIN_RESULT( minor_status, local_result, GLOBUS_GSI_GSSAPI_ERROR_WITH_GSI_PROXY); major_status = GSS_S_FAILURE; goto exit; } export_buffer->value = globus_common_create_string( "X509_USER_PROXY=%s", proxy_filename); export_buffer->length = strlen(export_buffer->value)+1; } else { major_status = GSS_S_FAILURE; GLOBUS_GSI_GSSAPI_ERROR_RESULT( minor_status, GLOBUS_GSI_GSSAPI_ERROR_BAD_ARGUMENT, (_GGSL("Unrecognized option_req of: %d"), option_req)); goto exit; } exit: if(proxy_filename != NULL) { free(proxy_filename); } if (bp) { BIO_free(bp); } GLOBUS_I_GSI_GSSAPI_DEBUG_EXIT; return major_status; }
/** * Calls the SSLeay error print routines to produce a printable * message. This may need some work, as the SSLeay error messages * are more of a trace, and my not be the best for the user. * Also don't take advantage of being called in a loop. * * @param minor_status * @param status_value * @param status_type * @param mech_type * @param message_context * @param status_string * * @return */ OM_uint32 GSS_CALLCONV gss_display_status( OM_uint32 * minor_status, OM_uint32 status_value, int status_type, const gss_OID mech_type, OM_uint32 * message_context, gss_buffer_t status_string) { globus_object_t * error_obj = NULL; char * error_chain_string = NULL; OM_uint32 major_status = GSS_S_COMPLETE; char * reason; static char * _function_name_ = "gss_display_status"; GLOBUS_I_GSI_GSSAPI_DEBUG_ENTER; status_string->length = 0; status_string->value = NULL; *minor_status = (OM_uint32) GLOBUS_SUCCESS; if (status_type == GSS_C_GSS_CODE) { if (!GSS_ERROR(status_value)) { reason = "GSS COMPLETE"; } else switch (GSS_ERROR(status_value)) { case GSS_S_FAILURE: reason = "General failure"; break; case GSS_S_DEFECTIVE_TOKEN: reason = "Communications Error"; break; case GSS_S_DEFECTIVE_CREDENTIAL: reason = "Authentication Failed"; break; case GSS_S_CREDENTIALS_EXPIRED: reason = "Credentials Expired"; break; case GSS_S_BAD_NAME: reason = "Service or hostname could " "not be understood"; break; case GSS_S_UNAUTHORIZED: reason = "Unexpected Gatekeeper or Service Name"; break; case GSS_S_NO_CRED: reason = "Problem with local credentials"; break; case GSS_S_BAD_SIG: reason = "Invalid signature on message"; break; default: reason = "Some Other GSS failure"; break; } status_string->value = globus_common_create_string( "GSS Major Status: %s\n",reason); status_string->length = strlen(status_string->value); major_status = GSS_S_COMPLETE; goto exit; } else if(status_type == GSS_C_MECH_CODE) { error_obj = globus_error_peek((globus_result_t) status_value); error_chain_string = globus_error_print_friendly(error_obj); status_string->value = globus_common_create_string( "GSS Minor Status Error Chain:\n%s", error_chain_string == NULL ? "(null)" : error_chain_string); globus_libc_free(error_chain_string); status_string->length = strlen(status_string->value); major_status = GSS_S_COMPLETE; goto exit; } else { major_status = GSS_S_BAD_STATUS; goto exit; } exit: GLOBUS_I_GSI_GSSAPI_DEBUG_EXIT; return major_status; }
/** * Add default values to RSL and verify required parameters * * Inserts default values to RSL when an RSL parameter is not defined * in it. After this is complete, it checks that all RSL parameters * with the "required_when" flag set are present in the RSL tree. * * @param request * Request which contains the RSL tree to validate. * @param when * Which RSL validation time scope we will use to decide * whether to use the default values or not. */ static int globus_l_gram_job_manager_insert_default_rsl( globus_gram_jobmanager_request_t * request, globus_rsl_t * rsl, globus_gram_job_manager_validation_when_t when) { globus_rvf_record_t * record; globus_list_t ** attributes; globus_rsl_t * new_relation; char * new_relation_str; globus_list_t * validation_records; int rc = GLOBUS_SUCCESS; attributes = globus_rsl_boolean_get_operand_list_ref(rsl); validation_records = request->manager->validation_records; while(!globus_list_empty(validation_records)) { record = globus_list_first(validation_records); validation_records = globus_list_rest(validation_records); if(record->default_value && (record->default_when&when)) { if(!globus_l_gram_job_manager_attribute_exists( *attributes, record->attribute)) { new_relation_str = globus_common_create_string( "%s = %s", record->attribute, record->default_value); globus_gram_job_manager_request_log( request, GLOBUS_GRAM_JOB_MANAGER_LOG_TRACE, "event=gram.validate_rsl.info " "level=TRACE " "msg=\"Inserting default RSL for attribute\" " "attribute=%s " "default=\"%s\" " "\n", record->attribute, record->default_value); new_relation = globus_rsl_parse(new_relation_str); globus_list_insert(attributes, new_relation); free(new_relation_str); } } if(record->required_when & when) { if(!globus_l_gram_job_manager_attribute_exists( *attributes, record->attribute)) { rc = globus_l_gram_job_manager_missing_value_error( record->attribute); globus_gram_job_manager_request_log( request, GLOBUS_GRAM_JOB_MANAGER_LOG_ERROR, "event=gram.validate_rsl.end " "level=ERROR " "msg=\"RSL missing required attribute\" " "attribute=%s " "\n", record->attribute); return rc; } } } return rc; }
int coInitConnect() { const char *envStr; char env[256], *portStr; float timeout; int32 handshake; int port; coSimLibData.soc = -1; #if !(defined(WIN32) || defined(WIN64)) /* we do our own handling of broken pipes */ signal(SIGPIPE, SIG_IGN); #endif /* get environment: if variable not set, exit with error-code */ envStr = getenv("CO_SIMLIB_CONN"); fprintf(stdout, "SIMLIB: %s\n", envStr); if ((!envStr) || (strlen(envStr) > 255)) return -1; /* Client connection */ strcpy(env, envStr); if (*env == 'C') { size_t retval; isServer = 0; /* get adress and port */ portStr = strchr(env, '/'); if (!portStr) { fprintf(stderr, "error parsing environment variable [%s]\n", env); return -1; } *portStr = '\0'; portStr++; retval = sscanf(portStr, "%d_%f_%d", &minPort, &timeout, &coSimLibData.verbose); if (retval != 3) { fprintf(stderr, "coInitConnect: sscanf failed\n"); return -1; } if (minPort < 1024 || minPort > 32767) return -1; #ifndef WIN32 if (!inet_aton(env + 2, &ip)) return -1; #else ip.s_addr = inet_addr(env + 2); if (ip.s_addr == -1) return -1; #endif if (coSimLibData.verbose > 0) fprintf(stderr, " Starting Client to %s Port %d with %f sec timeout\n", inet_ntoa(ip), minPort, timeout); /* we try to connect now */ if ((port = openClient(ip.s_addr, minPort, timeout)) < 0) return -1; } /* Server connection */ else if (*env == 'S') { size_t retval; isServer = 1; /* get adress and port */ portStr = strchr(env, ':'); if (!portStr) { fprintf(stderr, "error parsing environment variable [%s]\n", env); return -1; } *portStr = '\0'; portStr++; retval = sscanf(portStr, "%d-%d_%f_%d", &minPort, &maxPort, &timeout, &coSimLibData.verbose); if (retval != 4) { fprintf(stderr, "coInitConnect: sscanf failed\n"); return -1; } if (minPort < 1024 || minPort > 32767 || maxPort < 1024 || maxPort > 32767) return -1; /* we open and wait for the other side to connect */ if ((port = openServer(minPort, maxPort)) < 0) { fprintf(stderr, "could not open server\n"); return -1; } if (acceptServer(timeout) < 0) { fprintf(stderr, "could not accept server\n"); return -1; } } /* Neither Client nor Server = ERROR */ else return -1; /* Handshake: send 12345 to other side, so they might determine byte-swapping */ handshake = 12345; sendData(&handshake, sizeof(int32)); #ifdef HAVE_GLOBUS { globus_result_t result = GLOBUS_SUCCESS; xsd_any *fault; int err, fault_type; fprintf(stderr, "activate globus modules\n"); globus_module_activate(GLOBUS_COMMON_MODULE); globus_module_activate(GLOBUS_SOAP_MESSAGE_MODULE); registerSimulationType regSimulation; registerSimulationResponseType *regResponse; registerSimulationResponseType_init(®Response); globus_soap_message_attr_init(&message_attr); globus_soap_message_attr_set(message_attr, GLOBUS_SOAP_MESSAGE_AUTHZ_METHOD_KEY, NULL, NULL, (void *)GLOBUS_SOAP_MESSAGE_AUTHZ_HOST); globus_soap_message_attr_set(message_attr, GLOBUS_SOAP_MESSAGE_AUTH_PROTECTION_KEY, NULL, NULL, (void *)GLOBUS_SOAP_MESSAGE_AUTH_PROTECTION_PRIVACY); if ((result = SimulationService_client_init(&client_handle, message_attr, NULL)) == GLOBUS_SUCCESS) { char hostname[128]; struct passwd *user = getpwuid(getuid()); gethostname(hostname, 127); fprintf(stderr, "globus simulation client initialized\n"); regSimulation.user = user->pw_name; regSimulation.host = hostname; regSimulation.port = port; regSimulation.name = "Fenfloss"; fprintf(stderr, "globus regSimulation: [%s] [%s] [%d] [%s]\n", regSimulation.user, regSimulation.host, regSimulation.port, regSimulation.name); wsa_EndpointReferenceType_init(&epr); wsa_AttributedURI_init_contents(&epr->Address); xsd_anyURI_init_contents_cstr(&epr->Address.base_value, globus_common_create_string(getenv("GLOBUS_SIMULATIONSERVICE"))); fprintf(stderr, " [%s]\n", getenv("GLOBUS_SIMULATIONSERVICE")); if ((err = SimulationPortType_registerSimulation_epr(client_handle, epr, ®Simulation, ®Response, (SimulationPortType_registerSimulation_fault_t *)&fault_type, &fault)) == GLOBUS_SUCCESS) { SimulationType r = regResponse->result; simulationID = r.id; } else { fprintf(stderr, "globus error %d: [%s] \n", err, globus_object_printable_to_string(globus_error_get(err))); } } else { fprintf(stderr, "globus error %d: [%s] \n", result, globus_object_printable_to_string(globus_error_get(result))); } registerSimulationResponseType_destroy(regResponse); } #endif return 0; }
static int globus_l_job_manager_module_activate(void) { time_t timestamp_val; globus_l_job_manager_logfile_state_t * logfile_state; int rc; globus_reltime_t delay; globus_result_t result; char * scheduler; rc = globus_module_activate(GLOBUS_COMMON_MODULE); if (rc != GLOBUS_SUCCESS) { goto activate_common_failed; } rc = globus_mutex_init(&globus_l_job_manager_mutex, NULL); if (rc != GLOBUS_SUCCESS) { goto mutex_init_failed; } rc = globus_cond_init(&globus_l_job_manager_cond, NULL); if (rc != GLOBUS_SUCCESS) { goto cond_init_failed; } shutdown_called = GLOBUS_FALSE; callback_count = 0; GlobusDebugInit( SEG_JOB_MANAGER, SEG_JOB_MANAGER_DEBUG_INFO SEG_JOB_MANAGER_DEBUG_WARN SEG_JOB_MANAGER_DEBUG_ERROR SEG_JOB_MANAGER_DEBUG_TRACE); logfile_state = calloc(1, sizeof(globus_l_job_manager_logfile_state_t)); if (logfile_state == NULL) { goto calloc_state_failed; } /* Configuration info */ result = globus_scheduler_event_generator_get_timestamp(×tamp_val); if (result != GLOBUS_SUCCESS) { goto get_timestamp_failed; } if (timestamp_val != 0) { if (globus_libc_gmtime_r( ×tamp_val, &logfile_state->start_timestamp) == NULL) { goto gmtime_failed; } } scheduler = globus_libc_getenv(JOB_MANAGER_SEG_SCHEDULER); if (scheduler == NULL) { SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_ERROR, ("Error: %s not set\n", JOB_MANAGER_SEG_SCHEDULER)); result = GLOBUS_FAILURE; goto get_scheduler_failed; } if (getenv(JOB_MANAGER_SEG_LOG_PATH)) { logfile_state->log_dir = strdup(getenv(JOB_MANAGER_SEG_LOG_PATH)); } else { char * log_dir_pattern = globus_common_create_string( "${localstatedir}/lib/globus/globus-seg-%s", scheduler); globus_eval_path(log_dir_pattern, &logfile_state->log_dir); free(log_dir_pattern); } if (logfile_state->log_dir == NULL) { SEG_JOB_MANAGER_DEBUG(SEG_JOB_MANAGER_DEBUG_ERROR, ("Error: out of memory\n")); goto get_path_failed; } /* Convert timestamp to filename */ rc = globus_l_job_manager_find_logfile(logfile_state); if (rc == GLOBUS_SUCCESS) { logfile_state->fp = fopen(logfile_state->path, "r"); if (logfile_state->fp == NULL) { rc = SEG_JOB_MANAGER_ERROR_OUT_OF_MEMORY; goto fopen_failed; } GlobusTimeReltimeSet(delay, 0, 0); } else if(rc == SEG_JOB_MANAGER_ERROR_LOG_NOT_PRESENT) { GlobusTimeReltimeSet(delay, 1, 0); } else { goto bad_log_path; } result = globus_callback_register_oneshot( &logfile_state->callback, &delay, globus_l_job_manager_poll_callback, logfile_state); if (result != GLOBUS_SUCCESS) { goto oneshot_failed; } callback_count++; return 0; oneshot_failed: if (logfile_state->fp) { fclose(logfile_state->fp); } fopen_failed: if (logfile_state->path) { free(logfile_state->path); } bad_log_path: free(logfile_state->log_dir); get_path_failed: get_scheduler_failed: get_timestamp_failed: gmtime_failed: free(logfile_state); calloc_state_failed: globus_cond_destroy(&globus_l_job_manager_cond); cond_init_failed: globus_mutex_destroy(&globus_l_job_manager_mutex); mutex_init_failed: globus_module_deactivate(GLOBUS_COMMON_MODULE); activate_common_failed: return 1; }
/** * Write the response to an HTTP request * @ingroup globus_i_xio_http_server * * Generates an HTTP response line from a handle, and passes it to the * transport. The globus_l_xio_http_server_write_response_callback() will * be called once the transport has sent the response. * * This call may be triggered by either the first write on a server handle, * or by calling the #GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY handle * control function. * * Called with my mutex lock. * * @param http_handle * Handle associated with this HTTP stream. * @param iovec * Array of globus_xio_iovec_t structs associated with the user's write. * @param iovec_count * Length of the @a iovec array. If this is zero, we assume that the * response is being generated by the * #GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY control. * @param op * Operation associated with the write. If this is NULL (in the case * of the GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY control), one * will be created in this function. * * This function returns GLOBUS_SUCCESS, GLOBUS_XIO_ERROR_MEMORY, or an * error result from globus_xio_driver_operation_create(), or * globus_xio_driver_pass_write(). * * @retval GLOBUS_SUCCESS * Response was passed to the transport for writing. If this was generated * by a user writing data, then the write will occur after the * globus_l_xio_http_server_write_response_callback() has been called. * @retval GLOBUS_XIO_ERROR_MEMORY * Unable to compose the response due to memory constraints. */ globus_result_t globus_i_xio_http_server_write_response( globus_i_xio_http_handle_t * http_handle, const globus_xio_iovec_t * iovec, int iovec_count, globus_xio_operation_t op) { globus_result_t result; globus_fifo_t iovecs; const char * str; char code_str[5]; globus_xio_iovec_t * iov; int rc; int i; int send_size; char * size_buffer = NULL; globus_bool_t free_op = GLOBUS_FALSE; globus_xio_http_header_t * current_header; GlobusXIOName(globus_i_xio_server_write_response); globus_assert(http_handle->send_state == GLOBUS_XIO_HTTP_STATUS_LINE); rc = globus_fifo_init(&iovecs); if (rc != GLOBUS_SUCCESS) { result = GlobusXIOErrorMemory("iovecs"); goto error_exit; } /* Compose HTTP Response: * HTTP-Version SP Status-Code SP Reason-Phrase CRLF */ if (http_handle->response_info.http_version == GLOBUS_XIO_HTTP_VERSION_1_0) { str = "HTTP/1.0 "; } else { http_handle->response_info.http_version = GLOBUS_XIO_HTTP_VERSION_1_1; str = "HTTP/1.1 "; } GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, str, 9, free_iovecs_error); sprintf(code_str, "%d ", http_handle->response_info.status_code); GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, code_str, 4, free_iovecs_error); if (http_handle->response_info.reason_phrase != NULL) { str = http_handle->response_info.reason_phrase; } else { str = globus_i_xio_http_lookup_reason( http_handle->response_info.status_code); } GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, str, strlen(str), free_iovecs_error); GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, "\r\n", 2, free_iovecs_error); current_header = globus_hashtable_first( &http_handle->response_info.headers.headers); while (current_header) { GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, current_header->name, strlen(current_header->name), free_iovecs_error); GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, ": ", 2, free_iovecs_error); GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, current_header->value, strlen(current_header->value), free_iovecs_error); GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, "\r\n", 2, free_iovecs_error); current_header = globus_hashtable_next( &http_handle->response_info.headers.headers); } /* * Special headers we generate. */ if (GLOBUS_I_XIO_HTTP_HEADER_IS_CONNECTION_CLOSE( &http_handle->response_info.headers) || (http_handle->request_info.http_version == GLOBUS_XIO_HTTP_VERSION_1_0) || (http_handle->response_info.headers.transfer_encoding == GLOBUS_XIO_HTTP_TRANSFER_ENCODING_IDENTITY && GLOBUS_I_XIO_HTTP_HEADER_IS_CONTENT_LENGTH_SET( &http_handle->response_info.headers))) { http_handle->response_info.headers.flags |= GLOBUS_I_XIO_HTTP_HEADER_CONNECTION_CLOSE; GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, "Connection: close\r\n", 19, free_iovecs_error); } if (iovec_count > 0) { /* * We are sending a body, so we'll set the appropriate entity-related * headers */ if (http_handle->request_info.http_version == GLOBUS_XIO_HTTP_VERSION_1_0 || (http_handle->response_info.headers.transfer_encoding == GLOBUS_XIO_HTTP_TRANSFER_ENCODING_IDENTITY && GLOBUS_I_XIO_HTTP_HEADER_IS_CONTENT_LENGTH_SET( &http_handle->response_info.headers))) { http_handle->response_info.headers.transfer_encoding = GLOBUS_XIO_HTTP_TRANSFER_ENCODING_IDENTITY; /* Transfer-Encoding mustn't be sent to a HTTP/1.0 client */ if (http_handle->request_info.http_version != GLOBUS_XIO_HTTP_VERSION_1_0) { GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, "Transfer-Encoding: identity\r\n", 29, free_iovecs_error); } /* * When we know the content-length beforehand we can set it here, * otherwise, we will use the connection: close header */ if (GLOBUS_I_XIO_HTTP_HEADER_IS_CONTENT_LENGTH_SET( &http_handle->response_info.headers)) { GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, "Content-Length: ", 16, free_iovecs_error); size_buffer = globus_common_create_string( "%lu\r\n", (unsigned long) http_handle->response_info.headers.content_length); if (size_buffer == NULL) { result = GlobusXIOErrorMemory("iovec.iov_base"); goto free_iovecs_error; } GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, size_buffer, strlen(size_buffer), free_iovecs_error); free(size_buffer); size_buffer = NULL; } } else { http_handle->response_info.headers.transfer_encoding = GLOBUS_XIO_HTTP_TRANSFER_ENCODING_CHUNKED; GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, "Transfer-Encoding: chunked\r\n", 28, free_iovecs_error); } } GLOBUS_XIO_HTTP_COPY_BLOB(&iovecs, "\r\n", 2, free_iovecs_error); http_handle->header_iovcnt = globus_fifo_size(&iovecs); http_handle->header_iovec = globus_libc_malloc( http_handle->header_iovcnt * sizeof(globus_xio_iovec_t)); if (http_handle->header_iovec == NULL) { goto free_iovecs_error; } /* Convert fifo to iovec array, counting up size for wait_for_nbytes * parameter to globus_xio_driver_pass_write. */ for (i = 0, send_size = 0; i < http_handle->header_iovcnt; i++) { iov = globus_fifo_dequeue(&iovecs); globus_assert(iov != NULL); http_handle->header_iovec[i].iov_base = iov->iov_base; http_handle->header_iovec[i].iov_len = iov->iov_len; send_size += iov->iov_len; globus_libc_free(iov); } if (op == NULL) { result = globus_xio_driver_operation_create( &op, http_handle->handle); free_op = GLOBUS_TRUE; if (result != GLOBUS_SUCCESS) { goto free_headers_exit; } } /* Stash user buffer info until we've sent response headers */ http_handle->write_operation.operation = op; http_handle->write_operation.iov = (globus_xio_iovec_t *) iovec; http_handle->write_operation.iovcnt = iovec_count; http_handle->write_operation.wait_for = 0; result = globus_xio_driver_pass_write( http_handle->write_operation.operation, http_handle->header_iovec, http_handle->header_iovcnt, send_size, globus_l_xio_http_server_write_response_callback, http_handle); if (result != GLOBUS_SUCCESS) { goto free_operation_exit; } globus_fifo_destroy(&iovecs); if (iovec_count == 0) { http_handle->send_state = GLOBUS_XIO_HTTP_EOF; } else if (http_handle->response_info.headers.transfer_encoding == GLOBUS_XIO_HTTP_TRANSFER_ENCODING_CHUNKED) { http_handle->send_state = GLOBUS_XIO_HTTP_CHUNK_BODY; } else { http_handle->send_state = GLOBUS_XIO_HTTP_IDENTITY_BODY; } return GLOBUS_SUCCESS; free_operation_exit: if (free_op) { globus_xio_driver_operation_destroy( http_handle->write_operation.operation); } free_headers_exit: http_handle->write_operation.operation = NULL; http_handle->write_operation.driver_handle = NULL; http_handle->write_operation.iov = NULL; http_handle->write_operation.iovcnt = 0; http_handle->write_operation.wait_for = 0; for (i = 0; i < http_handle->header_iovcnt; i++) { globus_libc_free(http_handle->header_iovec[i].iov_base); } globus_libc_free(http_handle->header_iovec); http_handle->header_iovec = NULL; http_handle->header_iovcnt = 0; free_iovecs_error: while (!globus_fifo_empty(&iovecs)) { iov = globus_fifo_dequeue(&iovecs); globus_libc_free(iov->iov_base); globus_libc_free(iov); } globus_fifo_destroy(&iovecs); if (size_buffer != NULL) { free(size_buffer); } error_exit: return result; }
static void * globus_l_dsi_rest_thread( void *arg) { globus_l_dsi_rest_handle_t *dsi_rest_handle = arg; globus_xio_data_descriptor_t descriptor; size_t buf_size = 256; unsigned char *buf = malloc(buf_size); globus_size_t nbytes; char *encoded_uri; globus_mutex_lock(&dsi_rest_handle->mutex); while (!dsi_rest_handle->terminate) { char *method; char *uri; globus_xio_http_version_t http_version; globus_hashtable_t headers; globus_result_t result; globus_mutex_unlock(&dsi_rest_handle->mutex); result = globus_xio_server_accept( &dsi_rest_handle->xio_handle, dsi_rest_handle->xio_server); globus_mutex_lock(&dsi_rest_handle->mutex); if (result != GLOBUS_SUCCESS) { continue; } result = globus_xio_open( dsi_rest_handle->xio_handle, NULL, NULL); if (result != GLOBUS_SUCCESS) { goto end_this_socket; } result = globus_xio_data_descriptor_init(&descriptor, dsi_rest_handle->xio_handle); if (result != GLOBUS_SUCCESS) { goto end_this_socket; } result = globus_xio_read( dsi_rest_handle->xio_handle, buf, 0, 0, &nbytes, descriptor); if (result != GLOBUS_SUCCESS) { goto end_this_socket; } result = globus_xio_data_descriptor_cntl( descriptor, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_GET_REQUEST, &method, &uri, &http_version, &headers); globus_dsi_rest_uri_escape(uri, &encoded_uri); char *uripath = globus_common_create_string("%s/%s", dsi_rest_handle->root, encoded_uri); if (strcmp(method, "GET") == 0) { int fd; fd = open(uripath, O_RDONLY); if (fd < 0) { globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Connection", "Close"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Content-Length", "0"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE, 404); } else { globus_size_t read_amt = 0; globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Connection", "Close"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE, 200); do { read_amt = read(fd, buf, buf_size); if (read_amt > 0) { globus_size_t written_amt = 0; while (written_amt < read_amt) { globus_size_t this_write; result = globus_xio_write( dsi_rest_handle->xio_handle, buf+written_amt, read_amt-written_amt, read_amt-written_amt, &this_write, NULL); if (this_write > 0) { written_amt += this_write; } else if (result != GLOBUS_SUCCESS) { break; } } } } while (read_amt > 0); close(fd); } } else { int fd = open(uripath, O_WRONLY|O_CREAT, 0700); if (fd < 0) { globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE, 500); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Content-Length", "0"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Connection", "Close"); } else { off_t total_written=0; if (nbytes > 0) { globus_size_t written_amt = 0; while (written_amt < nbytes) { globus_size_t this_write; this_write = write(fd, buf+written_amt, nbytes-written_amt); if (this_write > 0) { written_amt += this_write; total_written += this_write; } } } do { result = globus_xio_read( dsi_rest_handle->xio_handle, buf, buf_size, 1, &nbytes, NULL); if (nbytes > 0) { globus_size_t written_amt = 0; while (written_amt < nbytes) { globus_size_t this_write; this_write = write(fd, buf+written_amt, nbytes-written_amt); if (this_write > 0) { written_amt += this_write; total_written += this_write; } } } if (result != GLOBUS_SUCCESS) { if (globus_error_match( globus_error_peek(result), GLOBUS_XIO_MODULE, GLOBUS_XIO_ERROR_EOF) || globus_xio_driver_error_match( dsi_rest_handle->http_driver, globus_error_peek(result), GLOBUS_XIO_HTTP_ERROR_EOF)) { result = GLOBUS_SUCCESS; break; } else { globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE, 500); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Content-Length", "0"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Connection", "Close"); goto xio_error; } } } while (nbytes > 0); close(fd); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_STATUS_CODE, 204); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Content-Length", "0"); globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_RESPONSE_HEADER, "Connection", "Close"); } } xio_error: free(uripath); result = globus_xio_handle_cntl( dsi_rest_handle->xio_handle, dsi_rest_handle->http_driver, GLOBUS_XIO_HTTP_HANDLE_SET_END_OF_ENTITY); end_this_socket: result = globus_xio_close( dsi_rest_handle->xio_handle, NULL); dsi_rest_handle->xio_handle = NULL; } dsi_rest_handle->terminate_complete = true; globus_cond_signal(&dsi_rest_handle->cond); globus_mutex_unlock(&dsi_rest_handle->mutex); return NULL; }
static globus_result_t globus_l_gfork_child_start( gfork_child_handle_t * out_handle, const char * in_env_suffix, globus_gfork_open_func_t open_cb, globus_gfork_closed_func_t close_cb, globus_gfork_incoming_cb_t incoming_cb, globus_gfork_error_func_t error_cb, void * user_arg, globus_bool_t master) { globus_result_t result; gfork_i_lib_handle_t * handle; char * env; char * env_suffix; int read_fd; int write_fd; handle = (gfork_i_lib_handle_t *) globus_calloc(1, sizeof(gfork_i_lib_handle_t)); handle->state = GFORK_STATE_OPEN; handle->open_cb = open_cb; handle->close_cb = close_cb; handle->error_cb = error_cb; handle->incoming_cb = incoming_cb; handle->user_arg = user_arg; handle->master = master; globus_mutex_init(&handle->mutex, NULL); globus_fifo_init(&handle->write_q); if(in_env_suffix == NULL) { env_suffix = ""; } else { env_suffix = (char *) in_env_suffix; } env = globus_common_create_string("%s%s", GFORK_CHILD_READ_ENV, env_suffix); result = gfork_l_get_env_fd(env, &read_fd); globus_free(env); if(result != GLOBUS_SUCCESS) { goto error_read_env; } env = globus_common_create_string("%s%s",GFORK_CHILD_WRITE_ENV,env_suffix); result = gfork_l_get_env_fd(env, &write_fd); globus_free(env); if(result != GLOBUS_SUCCESS) { goto error_write_env; } result = gfork_i_make_xio_handle(&handle->read_xio, read_fd); if(result != GLOBUS_SUCCESS) { goto error_read_convert; } result = gfork_i_make_xio_handle(&handle->write_xio, write_fd); if(result != GLOBUS_SUCCESS) { goto error_write_convert; } globus_mutex_lock(&handle->mutex); { result = globus_xio_register_read( handle->read_xio, (globus_byte_t *)&handle->header, sizeof(gfork_i_msg_header_t), sizeof(gfork_i_msg_header_t), NULL, gfork_l_child_read_header_cb, handle); if(result != GLOBUS_SUCCESS) { goto error_post; } } globus_mutex_unlock(&handle->mutex); *out_handle = handle; return GLOBUS_SUCCESS; error_post: gfork_l_child_error(handle, result); globus_mutex_unlock(&handle->mutex); error_write_convert: globus_xio_close(handle->read_xio, NULL); error_read_convert: error_write_env: error_read_env: globus_fifo_destroy(&handle->write_q); globus_mutex_destroy(&handle->mutex); globus_free(handle); return result; }
/** * @brief Parse log level specification * * @details * The globus_i_gram_parse_log_levels() function parses the log level string passed * in its first argument to the mask pointed to by the second argument. * The log level string contains one or more level names combined by the * "|" delimiter. The set of valid level names is: * - FATAL * - ERROR * - WARN * - INFO * - DEBUG * - TRACE * * @retval GLOBUS_SUCCESS * Success * @retval GLOBUS_GRAM_PROTOCOL_ERROR_GATEKEEPER_MISCONFIGURED * Server misconfigured */ int globus_i_gram_parse_log_levels( const char * unparsed_string, int * log_levels, char ** error_string) { char * log_level_string = strdup(unparsed_string); char * level_string = NULL; char * last_string = NULL; int rc = GLOBUS_SUCCESS; if (log_level_string == NULL) { rc = GLOBUS_GRAM_PROTOCOL_ERROR_MALLOC_FAILED; goto error_exit; } if (error_string != NULL) { *error_string = NULL; } *log_levels = 0; for (level_string = strtok_r(log_level_string, "|", &last_string); level_string != NULL; level_string = strtok_r(NULL, "|", &last_string)) { if (strcmp(level_string, "FATAL") == 0) { *log_levels |= GLOBUS_GRAM_JOB_MANAGER_LOG_FATAL; } else if (strcmp(level_string, "ERROR") == 0) { *log_levels |= GLOBUS_GRAM_JOB_MANAGER_LOG_ERROR; } else if (strcmp(level_string, "WARN") == 0) { *log_levels |= GLOBUS_GRAM_JOB_MANAGER_LOG_WARN; } else if (strcmp(level_string, "INFO") == 0) { *log_levels |= GLOBUS_GRAM_JOB_MANAGER_LOG_INFO; } else if (strcmp(level_string, "DEBUG") == 0) { *log_levels |= GLOBUS_GRAM_JOB_MANAGER_LOG_DEBUG; } else if (strcmp(level_string, "TRACE") == 0) { *log_levels |= GLOBUS_GRAM_JOB_MANAGER_LOG_TRACE; } else { globus_gram_job_manager_log( NULL, GLOBUS_GRAM_JOB_MANAGER_LOG_ERROR, "event=gram.config.info " "level=ERROR " "status=-1 " "msg=\"%s\" " "string=\"%s\" " "error_at=\"%s\" " "\n", "Error parsing log level string", unparsed_string, level_string); rc = GLOBUS_GRAM_PROTOCOL_ERROR_GATEKEEPER_MISCONFIGURED; if (error_string != NULL) { *error_string = globus_common_create_string( "Error parsing log level string '%s' at '%s'\n", unparsed_string, level_string); } break; } } free(log_level_string); error_exit: return rc; }
int main( int argc, char ** argv) { int rc = 0; globus_result_t result; char * cs; globus_xio_contact_t parsed_contact; char * new_banner; char * old_banner; GlobusGFSName(main); /* activte globus stuff */ if((rc = globus_module_activate(GLOBUS_COMMON_MODULE)) != GLOBUS_SUCCESS || (rc = globus_module_activate( GLOBUS_GRIDFTP_SERVER_MODULE)) != GLOBUS_SUCCESS) { fprintf(stderr, "Error: Failed to initialize:\n%s", globus_error_print_friendly(globus_error_peek(rc))); goto error_activate; } /* initialize global variables */ globus_mutex_init(&globus_l_gfs_mutex, GLOBUS_NULL); globus_cond_init(&globus_l_gfs_cond, GLOBUS_NULL); globus_l_gfs_signal_init(); globus_libc_printf("Embedded server starting.\n"); globus_mutex_lock(&globus_l_gfs_mutex); { result = globus_gridftp_server_embed_init( &globus_l_gfs_server_handle, argv); if(result != GLOBUS_SUCCESS) { rc = 1; goto error_lock; } /* add our acl module */ globus_gfs_acl_add_module(&globus_gfs_acl_test_module); /* customize some config */ old_banner = globus_gridftp_server_embed_config_get_string( globus_l_gfs_server_handle, "banner"); new_banner = globus_common_create_string( "%s\nEMBEDDED", old_banner); globus_gridftp_server_embed_config_set_ptr( globus_l_gfs_server_handle, "banner", new_banner); globus_free(old_banner); globus_gridftp_server_embed_config_set_int( globus_l_gfs_server_handle, "connections_max", 10); globus_gridftp_server_embed_config_set_int( globus_l_gfs_server_handle, "auth_level", 1 | /* identity check */ 2 | /* file access checks */ 4 | /* disable setuid (not really needed with gridmap disabled)*/ 8); /* disable gridmap lookup */ result = globus_gridftp_server_embed_start( globus_l_gfs_server_handle, globus_l_gfs_event_cb, NULL); if(result != GLOBUS_SUCCESS) { rc = 1; goto error_lock; } globus_l_gfs_server_active = GLOBUS_TRUE; cs = globus_gridftp_server_embed_config_get_string( globus_l_gfs_server_handle, "contact_string"); globus_xio_contact_parse(&parsed_contact, cs); globus_libc_printf( "Server listening on port %s.\n", parsed_contact.port); globus_xio_contact_destroy(&parsed_contact); /* run until we are done */ while(!globus_l_gfs_terminated || globus_l_gfs_server_active) { globus_cond_wait(&globus_l_gfs_cond, &globus_l_gfs_mutex); } } globus_mutex_unlock(&globus_l_gfs_mutex); globus_module_deactivate_all(); GlobusGFSDebugExit(); return 0; error_lock: globus_mutex_unlock(&globus_l_gfs_mutex); error_activate: globus_module_deactivate_all(); GlobusGFSDebugExitWithError(); return rc; }