static void sge_error_verror(sge_error_class_t* thiz, int error_type, int error_quality, const char*format, va_list ap) { sge_error_message_t *error = NULL; sge_error_t *et = (sge_error_t*)thiz->sge_error_handle; dstring ds = DSTRING_INIT; DENTER(TOP_LAYER, "sge_error_verror"); error = (sge_error_message_t*)sge_malloc(sizeof(sge_error_message_t)); error->error_quality = error_quality; error->error_type = error_type; sge_dstring_vsprintf(&ds, format, ap); error->message = strdup(sge_dstring_get_string(&ds)); error->next = NULL; sge_dstring_free(&ds); DPRINTF(("error: %s\n", error->message ? error->message : "")); if (et->first == NULL) { et->first = error; et->last = error; } else { et->last->next = error; et->last = error; } DEXIT; }
static bool check_all(dstring *sb) { bool ret = true; int i; /* sge_dstring_append */ printf("\nchecking sge_dstring_append\n"); sge_dstring_append(NULL, NULL); sge_dstring_append(sb, NULL); check_dstring(sb); sge_dstring_append(sb, "blah"); check_dstring(sb); sge_dstring_clear(sb); sge_dstring_append(sb, "too long string to fit into a static string buffer"); check_dstring(sb); sge_dstring_clear(sb); sge_dstring_append(sb, "long string that requires multiple chunks ....... "); check_dstring(sb); for (i = 0; i < 20; i++) { sge_dstring_append(sb, "long string that requires multiple chunks ....... "); } check_dstring(sb); /* sge_dstring_append_dstring */ printf("\nchecking sge_dstring_append_dstring\n"); sge_dstring_clear(sb); sge_dstring_append_dstring(NULL, NULL); { dstring second = DSTRING_INIT; sge_dstring_append(&second, "dstring"); sge_dstring_append_dstring(NULL, &second); sge_dstring_append_dstring(sb, NULL); sge_dstring_append_dstring(sb, &second); check_dstring(sb); sge_dstring_free(&second); } /* sge_dstring_append_char */ printf("\nchecking sge_dstring_append_char\n"); sge_dstring_clear(sb); sge_dstring_append_char(NULL, 'a'); sge_dstring_append_char(sb, '\0'); check_dstring(sb); sge_dstring_append_char(sb, 'a'); check_dstring(sb); sge_dstring_append_char(sb, 'b'); check_dstring(sb); /* sge_dstring_sprintf */ printf("\nchecking sge_dstring_sprintf\n"); sge_dstring_sprintf(NULL, "test %s", "string"); sge_dstring_sprintf(sb, NULL); sge_dstring_sprintf(sb, "test %s", "string"); check_dstring(sb); #if 0 /* does not build on irix */ /* sge_dstring_vsprintf */ printf("\nchecking sge_dstring_vsprintf\n"); { const char *args[] = { "string", NULL }; sge_dstring_clear(sb); sge_dstring_vsprintf(NULL, "test %s", args); sge_dstring_vsprintf(sb, NULL, args); sge_dstring_vsprintf(sb, "test %s", args); check_dstring(sb); } #endif /* sge_dstring_sprintf_append */ printf("\nchecking sge_dstring_sprintf_append\n"); sge_dstring_clear(sb); sge_dstring_sprintf_append(NULL, "test %s", "string"); sge_dstring_sprintf_append(sb, NULL); sge_dstring_sprintf_append(sb, "test %s", "string"); sge_dstring_sprintf_append(sb, " appended test %s", "string"); check_dstring(sb); /* sge_dstring_clear */ printf("\nchecking sge_dstring_clear\n"); sge_dstring_clear(NULL); sge_dstring_clear(sb); check_dstring(sb); /* sge_dstring_free */ printf("\nchecking sge_dstring_free\n"); sge_dstring_free(NULL); sge_dstring_free(sb); check_dstring(sb); /* sge_dstring_get_string */ printf("\nchecking sge_dstring_get_string\n"); sge_dstring_clear(sb); sge_dstring_append(sb, "test string"); { const char *result; result = sge_dstring_get_string(NULL); printf("sge_dstring_get_string(NULL) = %s\n", result == NULL ? "NULL" : result); result = sge_dstring_get_string(sb); printf("sge_dstring_get_string(sb) = %s\n", result == NULL ? "NULL" : result); } /* sge_dstring_copy_string */ printf("\nchecking sge_dstring_copy_string\n"); sge_dstring_copy_string(NULL, NULL); sge_dstring_copy_string(sb, NULL); sge_dstring_copy_string(NULL, "new test string"); sge_dstring_copy_string(sb, "new test string"); check_dstring(sb); /* sge_dstring_copy_dstring * check only NULL pointer behaviour, it just calls sge_dstring_copy_string */ printf("\nchecking sge_dstring_copy_dstring\n"); sge_dstring_copy_dstring(NULL, NULL); sge_dstring_copy_dstring(sb, NULL); check_dstring(sb); /* sge_dstring_strlen */ printf("\nchecking sge_dstring_strlen\n"); { int len; sge_dstring_copy_string(sb, "test string"); len = sge_dstring_strlen(NULL); printf("sge_dstring_strlen(NULL) = %d\n", len); len = sge_dstring_strlen(sb); printf("sge_dstring_strlen(sb) = %d\n", len); } /* sge_dstring_remaining */ printf("\nchecking sge_dstring_remaining\n"); { int len; sge_dstring_copy_string(sb, "test string"); len = sge_dstring_remaining(NULL); printf("sge_dstring_remaining(NULL) = %d\n", len); len = sge_dstring_remaining(sb); printf("sge_dstring_remaining(sb) = %d\n", len); } return ret; }
/****** shepherd_error ******************************************************** * NAME * shepherd_error() -- Write a line to the error file and exit program. * * SYNOPSIS * void shepherd_error(bool do_exit, const char *format, ...) * * FUNCTION * Writes a line to the error file, preceding it with a * date, time, uid and pid stamp, and exits the program. stops execution. * * INPUTS * do_exit: If true, this function calls exit(2). * format: The format string of the line to be written to the error file. * ...: The parameters to the format string. See printf(3c). * * RESULT * void - none *******************************************************************************/ void shepherd_error(int do_exit, const char *format, ...) { dstring ds; dstring message = DSTRING_INIT; char buffer[128]; char header_str[256]; struct stat statbuf; if (format != NULL) { va_list ap; va_start(ap, format); sge_dstring_vsprintf(&message, format, ap); va_end(ap); } shepherd_trace(sge_dstring_get_string(&message)); /* File was closed (e.g. by an exec()) but fp was not set to NULL */ if (shepherd_error_fp && fstat(fileno(shepherd_error_fp), &statbuf) == -1 && errno==EBADF) { shepherd_error_fp = NULL; } if (shepherd_error_fp == NULL) { shepherd_error_fp = shepherd_trace_init_intern(st_error); } if (shepherd_error_fp != NULL) { sge_dstring_init(&ds, buffer, sizeof(buffer)); sprintf(header_str, "%s ["uid_t_fmt":"pid_t_fmt"]: ", sge_ctime(0, &ds), geteuid(), getpid()); sh_str2file(header_str, sge_dstring_get_string(&message), shepherd_error_fp); } if (foreground) { fprintf(stderr, "%s%s\n", header_str, sge_dstring_get_string(&message)); } /* File was closed (e.g. by an exec()) but fp was not set to NULL */ if (shepherd_exit_status_fp && fstat(fileno(shepherd_exit_status_fp), &statbuf) == -1 && errno==EBADF ) { shepherd_exit_status_fp = NULL; } if (shepherd_exit_status_fp == NULL) { shepherd_exit_status_fp = shepherd_trace_init_intern(st_exit_status); } if (shepherd_exit_status_fp != NULL) { sprintf(header_str, "%d", shepherd_state); sh_str2file(header_str, NULL, shepherd_exit_status_fp); } if (coshepherd_pid > 0) { sge_switch2start_user(); kill(coshepherd_pid, SIGTERM); sge_switch2admin_user(); } if (g_new_interactive_job_support == false && search_conf_val("qrsh_control_port") != NULL) { char buffer[1024]; snprintf(buffer, sizeof(buffer), "1:%s", sge_dstring_get_string(&message)); write_to_qrsh(buffer); } sge_dstring_free(&message); if (do_exit) { /* close all trace files before exit */ shepherd_trace_exit(); exit(shepherd_state); } /* There are cases where we have to open and close the files * for every write. */ if (!g_keep_files_open) { shepherd_error_exit(); } }
/****** shepherd_trace ******************************************************** * NAME * shepherd_trace() -- Write line to trace file. * * SYNOPSIS * int shepherd_trace(const char *format, ...) * * FUNCTION * Writes a line to the trace file, preceding it with a date, time, uid * and pid stamp. * * INPUTS * format: The format string of the line to be written to the error file. * ...: The parameters to the format string. See printf(3c). * * RESULT * int - 0 if successful, 1 if an error occured. *******************************************************************************/ int shepherd_trace(const char *format, ...) { int ret = 1, old_cancelstate; struct stat statbuf; /* Protect the trace file pointer with a mutex */ pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancelstate); pthread_mutex_lock(&g_trace_mutex); /* File was closed (e.g. by an exec()) but fp was not set to NULL */ if (shepherd_trace_fp && fstat(fileno(shepherd_trace_fp), &statbuf) == -1 && errno == EBADF) { shepherd_trace_fp = NULL; } if (shepherd_trace_fp == NULL) { shepherd_trace_fp = shepherd_trace_init_intern(st_trace); } if (shepherd_trace_fp != NULL) { char buffer[128], header_str[256]; dstring ds, message = DSTRING_INIT; sge_dstring_init(&ds, buffer, sizeof(buffer)); sprintf(header_str, "%s ["uid_t_fmt":"pid_t_fmt"]: ", sge_ctime(0, &ds), geteuid(), getpid()); if (format != NULL) { va_list ap; va_start(ap, format); sge_dstring_vsprintf(&message, format, ap); va_end(ap); ret = sh_str2file(header_str, sge_dstring_get_string(&message), shepherd_trace_fp); if (foreground) { printf("%s%s\n", header_str, sge_dstring_get_string(&message)); fflush(stdout); } sge_dstring_free(&message); } /* There are cases where we have to open and close the files * for every write. */ if (!g_keep_files_open) { shepherd_trace_exit(); } ret=0; } pthread_mutex_unlock(&g_trace_mutex); pthread_setcancelstate(old_cancelstate, NULL); return ret; }