extern int voms_enabled;
static char *
-strmd5(const char *s, unsigned char *digest);
+strmd5(glite_renewal_core_context ctx, const char *s, unsigned char *digest);
static int
-get_record_ext(FILE *fd, proxy_record *record, int *last_used_suffix);
+get_record_ext(glite_renewal_core_context ctx, FILE *fd, proxy_record *record, int *last_used_suffix);
static int
-get_record(FILE *fd, proxy_record *record);
+get_record(glite_renewal_core_context ctx, FILE *fd, proxy_record *record);
static int
-store_record(char *basename, proxy_record *record);
+store_record(glite_renewal_core_context ctx, char *basename, proxy_record *record);
static int
-copy_file_content(FILE *in, FILE *out);
+copy_file_content(glite_renewal_core_context ctx, FILE *in, FILE *out);
static int
-copy_file(char *src, char *dst);
+copy_file(glite_renewal_core_context ctx, char *src, char *dst);
static int
-get_base_filename(char *proxy_file, char **basefilename);
+get_base_filename(glite_renewal_core_context ctx, char *proxy_file, char **basefilename);
int
-decode_record(char *line, proxy_record *record);
+decode_record(glite_renewal_core_context ctx, char *line, proxy_record *record);
int
-encode_record(proxy_record *record, char **line);
+encode_record(glite_renewal_core_context ctx, proxy_record *record, char **line);
static int
-open_metafile(char *proxy_file, FILE **fd);
+open_metafile(glite_renewal_core_context ctx, char *proxy_file, FILE **fd);
void
-free_record(proxy_record *record);
+free_record(glite_renewal_core_context ctx, proxy_record *record);
static int
-realloc_prd_list(prd_list *list);
+realloc_prd_list(glite_renewal_core_context ctx, prd_list *list);
/* make public: */
static int
-edg_wlpr_GetTokenInt(const char *msg, const size_t msg_len,
+edg_wlpr_GetTokenInt(glite_renewal_core_context ctx, const char *msg, const size_t msg_len,
const char *key, const char *separators,
int req_index, int *value);
static void
-record_to_response(int status_code, proxy_record *record,
+record_to_response(glite_renewal_core_context ctx, int status_code, proxy_record *record,
edg_wlpr_Response *response);
static int
-filename_to_response(char *filename, edg_wlpr_Response *response);
+filename_to_response(glite_renewal_core_context ctx, char *filename, edg_wlpr_Response *response);
static char *
-strmd5(const char *s, unsigned char *digest)
+strmd5(glite_renewal_core_context ctx, const char *s, unsigned char *digest)
{
MD5_CTX md5;
unsigned char d[16];
}
static int
-get_base_filename(char *proxy_file, char **basefilename)
+get_base_filename(glite_renewal_core_context ctx, char *proxy_file, char **basefilename)
{
char *subject = NULL;
char file[FILENAME_MAX];
assert(basefilename != NULL);
- ret = get_proxy_base_name(proxy_file, &subject);
+ ret = get_proxy_base_name(ctx, proxy_file, &subject);
if (ret)
goto end;
- snprintf(file, sizeof(file), "%s/%s", repository, strmd5(subject, NULL));
+ snprintf(file, sizeof(file), "%s/%s", repository, strmd5(ctx, subject, NULL));
*basefilename = strdup(file); /* XXX test ENOMEM */
ret = 0;
}
static int
-copy_file_content(FILE *in, FILE *out)
+copy_file_content(glite_renewal_core_context ctx, FILE *in, FILE *out)
{
char buf[1024];
size_t num;
while (1) {
num = fread(buf, sizeof(*buf), sizeof(buf), in);
if ((ret = ferror(in))) {
- edg_wlpr_Log(LOG_ERR, "Reading failed: %s", strerror(errno));
+ edg_wlpr_Log(ctx, LOG_ERR, "Reading failed: %s", strerror(errno));
return ret;
}
num = fwrite(buf, sizeof(*buf), num, out);
if ((ret = ferror(in))) {
- edg_wlpr_Log(LOG_ERR, "Writing failed: %s", strerror(errno));
+ edg_wlpr_Log(ctx, LOG_ERR, "Writing failed: %s", strerror(errno));
return ret;
}
if (feof(in))
/* return the time interval, after which the renewal should be started */
static time_t
-get_delta(time_t current_time, time_t start_time, time_t end_time)
+get_delta(glite_renewal_core_context ctx, time_t current_time, time_t start_time, time_t end_time)
{
time_t remaining_life;
time_t life_to_lose;
/* if the proxy is too short, renew it as soon as possible */
if (current_time + condor_limit > end_time ) {
- edg_wlpr_Log(LOG_ERR, "Remaining proxy lifetime fell below the value of the Condor limit!");
+ edg_wlpr_Log(ctx, LOG_ERR, "Remaining proxy lifetime fell below the value of the Condor limit!");
}
return 0;
}
int
-get_times(char *proxy_file, proxy_record *record)
+get_times(glite_renewal_core_context ctx, char *proxy_file, proxy_record *record)
{
FILE *fd;
X509 *cert = NULL;
fd = fopen(proxy_file, "r");
if (fd == NULL) {
- edg_wlpr_Log(LOG_ERR, "Opening proxy file %s failed: %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Opening proxy file %s failed: %s",
proxy_file, strerror(errno));
return errno;
}
cert = PEM_read_X509(fd, NULL, NULL, NULL);
if (cert == NULL) {
- edg_wlpr_Log(LOG_ERR, "Cannot read X.509 certificate from %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot read X.509 certificate from %s",
proxy_file);
ret = -1; /* XXX SSL_ERROR */
goto end;
ASN1_UTCTIME_free(asn1_time);
/* if (end_time - RENEWAL_CLOCK_SKEW < current_time) { Too short proxy } */
if (end_time + RENEWAL_CLOCK_SKEW < current_time) {
- edg_wlpr_Log(LOG_ERR, "Expired proxy in %s", proxy_file);
+ edg_wlpr_Log(ctx, LOG_ERR, "Expired proxy in %s", proxy_file);
ret = EDG_WLPR_PROXY_EXPIRED;
goto end;
}
ERR_clear_error();
break;
}
- edg_wlpr_Log(LOG_ERR, "Cannot read additional certificates from %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot read additional certificates from %s",
proxy_file);
ret = -1; /* XXX SSL_ERROR */
goto end;
}
globus_gsi_cert_utils_make_time(X509_get_notAfter(cert), &tmp_end);
if (tmp_end + RENEWAL_CLOCK_SKEW < current_time) {
- edg_wlpr_Log(LOG_ERR, "Expired proxy in %s", proxy_file);
+ edg_wlpr_Log(ctx, LOG_ERR, "Expired proxy in %s", proxy_file);
ret = EDG_WLPR_PROXY_EXPIRED;
goto end;
}
cert = NULL;
}
- record->next_renewal = current_time + get_delta(current_time, start_time,
+ record->next_renewal = current_time + get_delta(ctx, current_time, start_time,
end_time);
record->end_time = end_time;
ret = 0;
}
static int
-copy_file(char *src, char *dst)
+copy_file(glite_renewal_core_context ctx, char *src, char *dst)
{
FILE *from = NULL;
FILE *tmp_to = NULL;
from = fopen(src, "r");
if (from == NULL) {
- edg_wlpr_Log(LOG_ERR, "Cannot open file %s for reading (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot open file %s for reading (%s)",
src, strerror(errno));
return errno;
}
snprintf(tmpfile, sizeof(tmpfile), "%s.XXXXXX", dst);
tmp_fd = mkstemp(tmpfile);
if (tmp_fd == -1) {
- edg_wlpr_Log(LOG_ERR, "Cannot create temporary file (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot create temporary file (%s)",
strerror(errno));
ret = errno;
goto end;
tmp_to = fdopen(tmp_fd, "w");
if (tmp_to == NULL) {
- edg_wlpr_Log(LOG_ERR, "Cannot associate stream with temporary file (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot associate stream with temporary file (%s)",
strerror(errno));
unlink(tmpfile);
ret = errno;
goto end;
}
- ret = copy_file_content(from, tmp_to);
+ ret = copy_file_content(ctx, from, tmp_to);
fclose(tmp_to);
if (ret) {
goto end;
ret = rename(tmpfile, dst);
if (ret) {
- edg_wlpr_Log(LOG_ERR, "Cannot replace repository file %s with temporary file (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot replace repository file %s with temporary file (%s)",
strerror(errno));
unlink(tmpfile);
ret = errno;
}
void
-free_record(proxy_record *record)
+free_record(glite_renewal_core_context ctx, proxy_record *record)
{
int i;
}
static int
-realloc_prd_list(prd_list *list)
+realloc_prd_list(glite_renewal_core_context ctx, prd_list *list)
{
char **tmp;
}
static int
-get_jobids(const char *msg, const size_t msg_len, proxy_record *record)
+get_jobids(glite_renewal_core_context ctx, const char *msg, const size_t msg_len, proxy_record *record)
{
int index = 0;
int ret;
}
static int
-edg_wlpr_GetTokenInt(const char *msg, const size_t msg_len,
+edg_wlpr_GetTokenInt(glite_renewal_core_context ctx, const char *msg, const size_t msg_len,
const char *key, const char *separators,
int req_index, int *value)
{
}
int
-decode_record(char *line, proxy_record *record)
+decode_record(glite_renewal_core_context ctx, char *line, proxy_record *record)
{
/* line must be ended with '\0' */
int ret;
len = strlen(line) + 1;
- ret = edg_wlpr_GetTokenInt(line, len, "suffix=", SEPARATORS, 0,
+ ret = edg_wlpr_GetTokenInt(ctx, line, len, "suffix=", SEPARATORS, 0,
&record->suffix);
if (ret)
return ret;
#if 0
- ret = edg_wlpr_GetTokenInt(line, len, "counter=", SEPARATORS, 0,
+ ret = edg_wlpr_GetTokenInt(ctx, line, len, "counter=", SEPARATORS, 0,
&record->counter);
if (ret)
goto end;
#endif
- ret = edg_wlpr_GetTokenInt(line, len, "unique=", SEPARATORS, 0,
+ ret = edg_wlpr_GetTokenInt(ctx, line, len, "unique=", SEPARATORS, 0,
&record->unique);
if (ret)
goto end;
- ret = edg_wlpr_GetTokenInt(line, len, "voms_exts=", SEPARATORS, 0,
+ ret = edg_wlpr_GetTokenInt(ctx, line, len, "voms_exts=", SEPARATORS, 0,
&record->voms_exts);
ret = edg_wlpr_GetToken(line, len, "server=", SEPARATORS, 0,
if (ret)
goto end;
- ret = edg_wlpr_GetTokenInt(line, len, "next_renewal=", SEPARATORS, 0,
+ ret = edg_wlpr_GetTokenInt(ctx, line, len, "next_renewal=", SEPARATORS, 0,
(int *)&record->next_renewal);
if (ret)
goto end;
- ret = edg_wlpr_GetTokenInt(line, len, "end_time=", SEPARATORS, 0,
+ ret = edg_wlpr_GetTokenInt(ctx, line, len, "end_time=", SEPARATORS, 0,
(int *)&record->end_time);
if (ret)
goto end;
- ret = get_jobids(line, len, record);
+ ret = get_jobids(ctx, line, len, record);
if (ret)
goto end;
end:
if (ret)
- free_record(record);
+ free_record(ctx, record);
return ret;
}
int
-encode_record(proxy_record *record, char **line)
+encode_record(glite_renewal_core_context ctx, proxy_record *record, char **line)
{
char tmp_line[1024];
size_t jobids_len = 0;
/* Get proxy record from the index file. If no suffix is defined return a free
record with the smallest index */
static int
-get_record_ext(FILE *fd, proxy_record *record, int *last_used_suffix)
+get_record_ext(glite_renewal_core_context ctx, FILE *fd, proxy_record *record, int *last_used_suffix)
{
char line[1024];
int last_suffix = -1;
current_time = time(NULL);
while (fgets(line, sizeof(line), fd) != NULL) {
line_num++;
- free_record(&tmp_record);
+ free_record(ctx, &tmp_record);
p = strchr(line, '\n');
if (p)
*p = '\0';
- ret = decode_record(line, &tmp_record);
+ ret = decode_record(ctx, line, &tmp_record);
if (ret) {
- edg_wlpr_Log(LOG_ERR, "Skipping invalid entry at line %d", line_num);
+ edg_wlpr_Log(ctx, LOG_ERR, "Skipping invalid entry at line %d", line_num);
continue;
}
if (record->suffix >= 0) {
* parameters (currently myproxy location) provided by user */
record->suffix = tmp_record.suffix;
record->next_renewal = record->end_time = 0;
- free_record(&tmp_record);
+ free_record(ctx, &tmp_record);
return 0;
}
*last_used_suffix = last_suffix;
if (record->suffix >= 0) {
- edg_wlpr_Log(LOG_DEBUG, "Requested suffix %d not found in meta file",
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Requested suffix %d not found in meta file",
record->suffix);
}
- free_record(&tmp_record);
+ free_record(ctx, &tmp_record);
return EDG_WLPR_ERROR_PROTO_PARSE_NOT_FOUND;
}
static int
-get_record(FILE *fd, proxy_record *record)
+get_record(glite_renewal_core_context ctx, FILE *fd, proxy_record *record)
{
- return get_record_ext(fd, record, NULL);
+ return get_record_ext(ctx, fd, record, NULL);
}
static int
-store_record(char *basename, proxy_record *record)
+store_record(glite_renewal_core_context ctx, char *basename, proxy_record *record)
{
int stored = 0;
FILE *fd = NULL;
}
while (fgets(line, sizeof(line), fd) != NULL) {
line_num++;
- free_record(&tmp_record);
+ free_record(ctx, &tmp_record);
p = strchr(line, '\n');
if (p)
*p = '\0';
- ret = decode_record(line, &tmp_record);
+ ret = decode_record(ctx, line, &tmp_record);
if (ret) {
- edg_wlpr_Log(LOG_ERR, "Removing invalid entry at line %d in %s", line_num, basename);
+ edg_wlpr_Log(ctx, LOG_ERR, "Removing invalid entry at line %d in %s", line_num, basename);
continue;
}
if (record->suffix == tmp_record.suffix &&
tmp_record.jobids.len = 0;
tmp_record.jobids.val = NULL;
for (i = 0; i < record->jobids.len; i++) {
- realloc_prd_list(&tmp_record.jobids);
+ realloc_prd_list(ctx, &tmp_record.jobids);
tmp_record.jobids.val[tmp_record.jobids.len - 1] =
strdup(record->jobids.val[i]);
}
stored = 1;
}
- ret = encode_record(&tmp_record, &new_line);
+ ret = encode_record(ctx, &tmp_record, &new_line);
if (ret)
goto end;
dprintf(temp, "%s\n", new_line);
new_line = NULL;
}
if (! stored) {
- ret = encode_record(record, &new_line);
+ ret = encode_record(ctx, record, &new_line);
if (ret)
goto end;
ret = dprintf(temp, "%s\n", new_line);
ret = errno;
end:
- free_record(&tmp_record);
+ free_record(ctx, &tmp_record);
if (fd)
fclose(fd);
close(temp);
}
static int
-open_metafile(char *basename, FILE **fd)
+open_metafile(glite_renewal_core_context ctx, char *basename, FILE **fd)
{
FILE *meta_fd;
char meta_filename[FILENAME_MAX];
snprintf(meta_filename, sizeof(meta_filename), "%s.data", basename);
meta_fd = fopen(meta_filename, "a+");
if (meta_fd == NULL) {
- edg_wlpr_Log(LOG_ERR, "Opening meta file %s failed (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Opening meta file %s failed (%s)",
meta_filename, strerror(errno));
return errno;
}
rewind(meta_fd);
*fd = meta_fd;
- edg_wlpr_Log(LOG_DEBUG, "Using meta file %s", meta_filename);
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Using meta file %s", meta_filename);
return 0;
}
static int
-filename_to_response(char *filename, edg_wlpr_Response *response)
+filename_to_response(glite_renewal_core_context ctx, char *filename, edg_wlpr_Response *response)
{
response->filenames = malloc(2 * sizeof(*response->filenames));
if (response->filenames == NULL) {
- edg_wlpr_Log(LOG_DEBUG, "Not enough memory");
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Not enough memory");
return errno;
}
response->filenames[0] = strdup(filename);
if (response->filenames[0] == NULL) {
- edg_wlpr_Log(LOG_DEBUG, "Not enough memory");
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Not enough memory");
free(response->filenames);
return errno;
}
}
static void
-record_to_response(int status_code, proxy_record *record,
+record_to_response(glite_renewal_core_context ctx, int status_code, proxy_record *record,
edg_wlpr_Response *response)
{
/* XXX Neni struktrura proxy_record zbytecna? Mohla by se pouzivat primo
}
int
-check_proxyname(char *datafile, char *jobid, char **filename)
+check_proxyname(glite_renewal_core_context ctx, char *datafile, char *jobid, char **filename)
{
proxy_record record;
FILE *meta_fd = NULL;
meta_fd = fopen(datafile, "r");
if (meta_fd == NULL) {
- edg_wlpr_Log(LOG_ERR, "Cannot open meta file %s (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot open meta file %s (%s)",
datafile, strerror(errno));
return errno;
}
while (fgets(line, sizeof(line), meta_fd) != NULL) {
- free_record(&record);
+ free_record(ctx, &record);
p = strchr(line, '\n');
if (p)
*p = '\0';
- ret = decode_record(line, &record);
+ ret = decode_record(ctx, line, &record);
if (ret)
continue; /* XXX exit? */
for (i = 0; i < record.jobids.len; i++) {
p = strrchr(proxy, '.');
sprintf(p, ".%d", record.suffix);
*filename = strdup(proxy);
- free_record(&record);
+ free_record(ctx, &record);
fclose(meta_fd);
return 0;
}
}
}
- free_record(&record);
+ free_record(ctx, &record);
fclose(meta_fd);
return EDG_WLPR_ERROR_PROTO_PARSE_NOT_FOUND;
}
int
-find_proxyname(char *jobid, char **filename)
+find_proxyname(glite_renewal_core_context ctx, char *jobid, char **filename)
{
DIR *dir = NULL;
struct dirent *file;
dir = opendir(repository);
if (dir == NULL) {
- edg_wlpr_Log(LOG_ERR, "Cannot open repository directory %s (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot open repository directory %s (%s)",
repository, strerror(errno));
return errno;
}
if (file->d_name == NULL || strlen(file->d_name) != 37 ||
strcmp(file->d_name + 32, ".data") != 0)
continue;
- ret = check_proxyname(file->d_name, jobid, filename);
+ ret = check_proxyname(ctx, file->d_name, jobid, filename);
if (ret == 0) {
closedir(dir);
return 0;
}
}
closedir(dir);
- edg_wlpr_Log(LOG_ERR, "Requested proxy is not registered");
+ edg_wlpr_Log(ctx, LOG_ERR, "Requested proxy is not registered");
return EDG_WLPR_PROXY_NOT_REGISTERED;
}
#ifdef NOVOMS
int
-find_voms_cert(char *file, int *present)
+find_voms_cert(glite_renewal_core_context ctx, char *file, int *present)
{
*present = 0;
return 0;
#else
int
-find_voms_cert(char *file, int *present)
+find_voms_cert(glite_renewal_core_context ctx, char *file, int *present)
{
struct vomsdata *voms_info = NULL;
STACK_OF(X509) *chain = NULL;
voms_info = VOMS_Init(vomsdir, cadir);
if (voms_info == NULL) {
- edg_wlpr_Log(LOG_ERR, "check_voms_cert(): Cannot initialize VOMS context (VOMS_Init() failed, probably voms dir was not specified)");
+ edg_wlpr_Log(ctx, LOG_ERR, "check_voms_cert(): Cannot initialize VOMS context (VOMS_Init() failed, probably voms dir was not specified)");
return EDG_WLPR_ERROR_VOMS;
}
- ret = load_proxy(file, &cert, &privkey, &chain, NULL);
+ ret = load_proxy(ctx, file, &cert, &privkey, &chain, NULL);
if (ret) {
VOMS_Destroy(voms_info);
return ret;
#endif
void
-register_proxy(edg_wlpr_Request *request, edg_wlpr_Response *response)
+register_proxy(glite_renewal_core_context ctx, edg_wlpr_Request *request, edg_wlpr_Response *response)
{
proxy_record record;
int ret;
memset(&record, 0, sizeof(record));
memset(response, 0, sizeof(*response));
- edg_wlpr_Log(LOG_DEBUG, "Registration request for %s", request->proxy_filename);
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Registration request for %s", request->proxy_filename);
if (request->proxy_filename == NULL || request->jobid == NULL) {
- edg_wlpr_Log(LOG_ERR, "Registration request doesn't contain registration information");
+ edg_wlpr_Log(ctx, LOG_ERR, "Registration request doesn't contain registration information");
return; /* EINVAL; */
}
umask(0177);
- ret = get_base_filename(request->proxy_filename, &basename);
+ ret = get_base_filename(ctx, request->proxy_filename, &basename);
if (ret)
goto end;
- ret = open_metafile(basename, &meta_fd);
+ ret = open_metafile(ctx, basename, &meta_fd);
if (ret)
goto end;
if (voms_enabled)
- ret = find_voms_cert(request->proxy_filename, &record.voms_exts);
+ ret = find_voms_cert(ctx, request->proxy_filename, &record.voms_exts);
/* ignore VOMS related error */
/* Find first free record */
record.suffix = -1;
record.myproxy_server = strdup(request->myproxy_server);
- ret = get_record_ext(meta_fd, &record, &last_suffix);
+ ret = get_record_ext(ctx, meta_fd, &record, &last_suffix);
fclose(meta_fd); meta_fd = NULL;
if (ret && ret != EDG_WLPR_ERROR_PROTO_PARSE_NOT_FOUND)
goto end;
suffix = (record.jobids.len == 0 && record.suffix >= 0) ?
record.suffix : last_suffix + 1;
snprintf(filename, sizeof(filename), "%s.%d", basename, suffix);
- ret = copy_file(request->proxy_filename, filename);
+ ret = copy_file(ctx, request->proxy_filename, filename);
if (ret)
goto end;
- ret = get_times(filename, &record);
+ ret = get_times(ctx, filename, &record);
if (ret)
goto end;
record.suffix = suffix;
- ret = realloc_prd_list(&record.jobids);
+ ret = realloc_prd_list(ctx, &record.jobids);
if (ret)
goto end;
record.jobids.val[record.jobids.len - 1] = strdup(request->jobid);
record.unique = request->unique;
- edg_wlpr_Log(LOG_DEBUG, "Created a new proxy file in repository (%s)",
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Created a new proxy file in repository (%s)",
filename);
} else {
- ret = realloc_prd_list(&record.jobids);
+ ret = realloc_prd_list(ctx, &record.jobids);
if (ret)
goto end;
record.jobids.val[record.jobids.len - 1] = strdup(request->jobid);
snprintf(filename, sizeof(filename), "%s.%d", basename, record.suffix);
- edg_wlpr_Log(LOG_DEBUG, "Inremented counter on %s", filename);
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Inremented counter on %s", filename);
}
- ret = store_record(basename, &record);
+ ret = store_record(ctx, basename, &record);
end:
if (meta_fd) {
free(basename);
if (ret == 0)
- ret = filename_to_response(filename, response);
- record_to_response(ret, &record, response);
- free_record(&record);
+ ret = filename_to_response(ctx, filename, response);
+ record_to_response(ctx, ret, &record, response);
+ free_record(ctx, &record);
}
void
-unregister_proxy(edg_wlpr_Request *request, edg_wlpr_Response *response)
+unregister_proxy(glite_renewal_core_context ctx, edg_wlpr_Request *request, edg_wlpr_Response *response)
{
proxy_record record;
int ret, i, index;
struct stat stat_buf;
memset(&record, 0, sizeof(record));
- edg_wlpr_Log(LOG_DEBUG, "Unregistration request for %s", request->jobid);
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Unregistration request for %s", request->jobid);
if (request->jobid == NULL) {
- edg_wlpr_Log(LOG_ERR, "Unregistration request doesn't contain needed information");
+ edg_wlpr_Log(ctx, LOG_ERR, "Unregistration request doesn't contain needed information");
ret = EINVAL;
goto end;
}
if (request->proxy_filename == NULL) {
- ret = find_proxyname(request->jobid, &request->proxy_filename);
+ ret = find_proxyname(ctx, request->jobid, &request->proxy_filename);
if (ret)
goto end;
}
- ret = get_base_filename(request->proxy_filename, &basename);
+ ret = get_base_filename(ctx, request->proxy_filename, &basename);
if (ret) {
goto end;
}
if (strncmp(request->proxy_filename, basename, strlen(basename) != 0)) {
- edg_wlpr_Log(LOG_DEBUG, "Requested proxy %s is not from repository",
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Requested proxy %s is not from repository",
request->proxy_filename);
ret = EDG_WLPR_PROXY_NOT_REGISTERED;
goto end;
p = strrchr(request->proxy_filename, '.');
if (p == NULL) {
- edg_wlpr_Log(LOG_DEBUG, "Requested proxy %s is not from repository",
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Requested proxy %s is not from repository",
request->proxy_filename);
ret = EDG_WLPR_PROXY_NOT_REGISTERED;
goto end;
ret = edg_wlpr_DecodeInt(p+1, &record.suffix);
if (ret) {
- edg_wlpr_Log(LOG_DEBUG, "Requested proxy %s is not from repository",
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Requested proxy %s is not from repository",
request->proxy_filename);
ret = EDG_WLPR_PROXY_NOT_REGISTERED;
goto end;
}
- ret = open_metafile(basename, &meta_fd);
+ ret = open_metafile(ctx, basename, &meta_fd);
if (ret) {
/* fill in error response */
return;
}
- ret = get_record(meta_fd, &record);
+ ret = get_record(ctx, meta_fd, &record);
if (ret)
goto end;
break;
}
if (ret) {
- edg_wlpr_Log(LOG_DEBUG, "Requested proxy %s is not registered",
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Requested proxy %s is not registered",
request->proxy_filename);
goto end;
}
ret = stat(request->proxy_filename, &stat_buf);
if (ret) {
- edg_wlpr_Log(LOG_DEBUG, "Cannot stat file %s: (%s)",
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Cannot stat file %s: (%s)",
request->proxy_filename, strerror(errno));
ret = errno;
goto end;
}
- ret = store_record(basename, &record);
+ ret = store_record(ctx, basename, &record);
if (ret)
goto end;
free(basename);
if (ret == 0)
- ret = filename_to_response(request->proxy_filename, response);
- record_to_response(ret, &record, response);
- free_record(&record);
+ ret = filename_to_response(ctx, request->proxy_filename, response);
+ record_to_response(ctx, ret, &record, response);
+ free_record(ctx, &record);
}
void
-get_proxy(edg_wlpr_Request *request, edg_wlpr_Response *response)
+get_proxy(glite_renewal_core_context ctx, edg_wlpr_Request *request, edg_wlpr_Response *response)
{
char *filename = NULL;
int ret;
memset(response, 0, sizeof(*response));
- edg_wlpr_Log(LOG_DEBUG, "GET request for %s", request->jobid);
+ edg_wlpr_Log(ctx, LOG_DEBUG, "GET request for %s", request->jobid);
if (request->jobid == NULL) {
- edg_wlpr_Log(LOG_ERR, "GET request doesn't contain jobid specification");
+ edg_wlpr_Log(ctx, LOG_ERR, "GET request doesn't contain jobid specification");
ret = EINVAL;
goto end;
}
- ret = find_proxyname(request->jobid, &filename);
+ ret = find_proxyname(ctx, request->jobid, &filename);
end:
if (ret == 0)
- ret = filename_to_response(filename, response);
+ ret = filename_to_response(ctx, filename, response);
if (filename)
free(filename);
response->response_code = ret;
}
void
-update_db(edg_wlpr_Request *request, edg_wlpr_Response *response)
+update_db(glite_renewal_core_context ctx, edg_wlpr_Request *request, edg_wlpr_Response *response)
{
FILE *fd = NULL;
int tmp_fd = -1;
memset(&record, 0, sizeof(record));
- edg_wlpr_Log(LOG_DEBUG, "UPDATE_DB request for %s", request->proxy_filename);
+ edg_wlpr_Log(ctx, LOG_DEBUG, "UPDATE_DB request for %s", request->proxy_filename);
chdir(repository);
basename = request->proxy_filename;
snprintf(datafile, sizeof(datafile), "%s.data", basename);
fd = fopen(datafile, "r");
if (fd == NULL) {
- edg_wlpr_Log(LOG_ERR, "Cannot open meta file %s (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot open meta file %s (%s)",
datafile, strerror(errno));
ret = errno;
return;
snprintf(tmp_file, sizeof(tmp_file), "%s.XXXXXX", datafile);
tmp_fd = mkstemp(tmp_file);
if (tmp_fd < 0) {
- edg_wlpr_Log(LOG_ERR, "Cannot create temporary file (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot create temporary file (%s)",
strerror(errno));
ret = errno;
goto end;
current_time = time(NULL);
while (fgets(line, sizeof(line), fd) != NULL) {
- free_record(&record);
+ free_record(ctx, &record);
p = strchr(line, '\n');
if (p)
*p = '\0';
- ret = decode_record(line, &record);
+ ret = decode_record(ctx, line, &record);
if (ret)
goto end;
/* remove file with expired proxy and clean the record in db */
unlink(cur_proxy);
server = strdup(record.myproxy_server);
- free_record(&record);
+ free_record(ctx, &record);
record.suffix = suffix;
record.myproxy_server = server;
- edg_wlpr_Log(LOG_WARNING, "Removed expired proxy %s", cur_proxy);
+ edg_wlpr_Log(ctx, LOG_WARNING, "Removed expired proxy %s", cur_proxy);
} else
- get_times(cur_proxy, &record);
+ get_times(ctx, cur_proxy, &record);
} else {
- ret = get_times(proxy, &record);
+ ret = get_times(ctx, proxy, &record);
(ret == 0) ? rename(proxy, cur_proxy) : unlink(proxy);
}
}
- ret = encode_record(&record, &new_line);
+ ret = encode_record(ctx, &record, &new_line);
if (ret)
goto end;
free(new_line);
new_line = NULL;
}
- free_record(&record);
+ free_record(ctx, &record);
close(tmp_fd);
fclose(fd);
unlink(tmp_file);
if (tmp_fd > 0)
close(tmp_fd);
- free_record(&record);
+ free_record(ctx, &record);
return;
}
static int received_signal = -1, die = 0;
static void
-check_renewal(char *datafile, int force_renew, int *num_renewed);
+check_renewal(glite_renewal_core_context ctx, char *datafile, int force_renew, int *num_renewed);
static int
-renew_proxy(proxy_record *record, char *basename, char **new_proxy);
+renew_proxy(glite_renewal_core_context ctx, proxy_record *record, char *basename, char **new_proxy);
static void
register_signal(int signal);
+/* XXX remove once the renew_core libs is used */
+#if 1
int
-load_proxy(const char *cur_file, X509 **cert, EVP_PKEY **priv_key,
+load_proxy(glite_renewal_core_context ctx, const char *cur_file, X509 **cert, EVP_PKEY **priv_key,
STACK_OF(X509) **chain, globus_gsi_cred_handle_t *cur_proxy)
{
globus_result_t result;
return ret;
}
+#endif
static void
register_signal(int signal)
}
static int
-renew_proxy(proxy_record *record, char *basename, char **new_proxy)
+renew_proxy(glite_renewal_core_context ctx, proxy_record *record, char *basename, char **new_proxy)
{
char tmp_proxy[FILENAME_MAX];
int tmp_fd;
myproxy_set_delegation_defaults(socket_attrs, client_request);
- edg_wlpr_Log(LOG_DEBUG, "Trying to renew proxy in %s.%d",
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Trying to renew proxy in %s.%d",
basename, record->suffix);
snprintf(tmp_proxy, sizeof(tmp_proxy), "%s.%d.myproxy.XXXXXX",
basename, record->suffix);
tmp_fd = mkstemp(tmp_proxy);
if (tmp_fd == -1) {
- edg_wlpr_Log(LOG_ERR, "Cannot create temporary file (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot create temporary file (%s)",
strerror(errno));
return errno;
}
snprintf(repository_file, sizeof(repository_file),"%s.%d",
basename, record->suffix);
- ret = get_proxy_base_name(repository_file, &client_request->username);
+ ret = get_proxy_base_name(ctx, repository_file, &client_request->username);
if (ret)
goto end;
server = (record->myproxy_server) ? record->myproxy_server :
socket_attrs->pshost;
if (server == NULL) {
- edg_wlpr_Log(LOG_ERR, "No myproxy server specified");
+ edg_wlpr_Log(ctx, LOG_ERR, "No myproxy server specified");
ret = EINVAL;
goto end;
}
server_response, tmp_proxy);
if (ret == 1) {
ret = EDG_WLPR_ERROR_MYPROXY;
- edg_wlpr_Log(LOG_ERR, "Error contacting MyProxy server for proxy %s: %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Error contacting MyProxy server for proxy %s: %s",
repository_file, verror_get_string());
verror_clear();
goto end;
basename, record->suffix);
tmp_voms_fd = mkstemp(tmp_voms_proxy);
if (tmp_voms_fd == -1) {
- edg_wlpr_Log(LOG_ERR, "Cannot create temporary file (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot create temporary file (%s)",
strerror(errno));
ret = errno;
goto end;
}
- ret = renew_voms_creds(repository_file, renewed_proxy, tmp_voms_proxy);
+ ret = renew_voms_creds(ctx, repository_file, renewed_proxy, tmp_voms_proxy);
close(tmp_voms_fd);
if (ret) {
unlink(tmp_voms_proxy);
}
static void
-check_renewal(char *datafile, int force_renew, int *num_renewed)
+check_renewal(glite_renewal_core_context ctx, char *datafile, int force_renew, int *num_renewed)
{
char line[1024];
proxy_record record;
strncpy(basename, datafile, sizeof(basename) - 1);
p = basename + strlen(basename) - strlen(".data");
if (strcmp(p, ".data") != 0) {
- edg_wlpr_Log(LOG_ERR, "Meta filename doesn't end with '.data'");
+ edg_wlpr_Log(ctx, LOG_ERR, "Meta filename doesn't end with '.data'");
return;
}
*p = '\0';
meta_fd = fopen(datafile, "r");
if (meta_fd == NULL) {
- edg_wlpr_Log(LOG_ERR, "Cannot open meta file %s (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot open meta file %s (%s)",
datafile, strerror(errno));
return;
}
current_time = time(NULL);
- edg_wlpr_Log(LOG_DEBUG, "Reading metafile %s", datafile);
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Reading metafile %s", datafile);
while (fgets(line, sizeof(line), meta_fd) != NULL) {
- free_record(&record);
+ free_record(ctx, &record);
p = strchr(line, '\n');
if (p)
*p = '\0';
- ret = decode_record(line, &record);
+ ret = decode_record(ctx, line, &record);
if (ret)
continue; /* XXX exit? */
if (record.jobids.len == 0) /* no jobid registered for this proxy */
ret = EDG_WLPR_PROXY_EXPIRED;
if ( record.end_time + RENEWAL_CLOCK_SKEW >= current_time) {
/* only try renewal if the proxy hasn't already expired */
- ret = renew_proxy(&record, basename, &new_proxy);
+ ret = renew_proxy(ctx, &record, basename, &new_proxy);
}
/* if the proxy wasn't renewed have the daemon planned another renewal */
tmp = realloc(request.entries, (num + 2) * sizeof(*tmp));
if (tmp == NULL) {
- free_record(&record);
+ free_record(ctx, &record);
return;
}
request.entries = tmp;
num++;
}
}
- free_record(&record);
+ free_record(ctx, &record);
if (num > 0) {
ret = edg_wlpr_RequestSend(&request, &response);
if (ret != 0)
- edg_wlpr_Log(LOG_ERR,
+ edg_wlpr_Log(ctx, LOG_ERR,
"Failed to send update request to master (%d)", ret);
else if (response.response_code != 0)
- edg_wlpr_Log(LOG_ERR,
+ edg_wlpr_Log(ctx, LOG_ERR,
"Master failed to update database (%d)", response.response_code);
/* delete all tmp proxy files which may survive */
return;
}
-int renewal(int force_renew, int *num_renewed)
+int renewal(glite_renewal_core_context ctx, int force_renew, int *num_renewed)
{
DIR *dir = NULL;
struct dirent *file;
FILE *fd;
int num = 0;
- edg_wlpr_Log(LOG_DEBUG, "Starting renewal process");
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Starting renewal process");
*num_renewed = 0;
if (chdir(repository)) {
- edg_wlpr_Log(LOG_ERR, "Cannot access repository directory %s (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot access repository directory %s (%s)",
repository, strerror(errno));
return errno;
}
dir = opendir(repository);
if (dir == NULL) {
- edg_wlpr_Log(LOG_ERR, "Cannot open repository directory %s (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot open repository directory %s (%s)",
repository, strerror(errno));
return errno;
}
continue;
fd = fopen(file->d_name, "r");
if (fd == NULL) {
- edg_wlpr_Log(LOG_ERR, "Cannot open meta file %s (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot open meta file %s (%s)",
file->d_name, strerror(errno));
continue;
}
- check_renewal(file->d_name, force_renew, &num);
+ check_renewal(ctx, file->d_name, force_renew, &num);
*num_renewed += num;
fclose(fd);
}
closedir(dir);
- edg_wlpr_Log(LOG_DEBUG, "Finishing renewal process");
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Finishing renewal process");
return 0;
}
void
-watchdog_start(void)
+watchdog_start(glite_renewal_core_context ctx)
{
struct sigaction sa;
int force_renewal;
if (die)
break;
/* XXX uninstall signal handler ? */
- renewal(force_renewal, &num);
+ renewal(ctx, force_renewal, &num);
count += num;
}
- edg_wlpr_Log(LOG_DEBUG, "Terminating after %d renewal attempts", count);
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Terminating after %d renewal attempts", count);
exit(0);
}
static const char rcsid[] = "$Id$";
int
-load_proxy(const char *cur_file, X509 **cert, EVP_PKEY **priv_key,
+load_proxy(glite_renewal_core_context ctx, const char *cur_file, X509 **cert, EVP_PKEY **priv_key,
STACK_OF(X509) **chain, globus_gsi_cred_handle_t *cur_proxy)
{
globus_result_t result;
}
int
-get_proxy_base_name(char *file, char **name)
+get_proxy_base_name(glite_renewal_core_context ctx, char *file, char **name)
{
X509 *cert = NULL;
EVP_PKEY *key = NULL;
X509_NAME *subject = NULL;
int ret;
- ret = load_proxy(file, &cert, &key, &chain, NULL);
+ ret = load_proxy(ctx, file, &cert, &key, &chain, NULL);
if (ret)
return ret;
ret = globus_gsi_cert_utils_get_base_name(subject, chain);
if (ret) {
- edg_wlpr_Log(LOG_ERR, "Cannot get subject name from proxy %s", file);
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot get subject name from proxy %s", file);
ret = EDG_WLPR_ERROR_SSL; /* XXX ??? */
goto end;
}
}
int
-glite_renewal_core_renew(glite_renewal_core_context context,
+glite_renewal_core_renew(glite_renewal_core_context ctx,
const char * myproxy_server,
unsigned int myproxy_port,
const char *current_proxy,
myproxy_set_delegation_defaults(socket_attrs, client_request);
- edg_wlpr_Log(LOG_DEBUG, "Trying to renew proxy in %s", current_proxy);
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Trying to renew proxy in %s", current_proxy);
snprintf(tmp_proxy, sizeof(tmp_proxy), "%s.myproxy.XXXXXX", current_proxy);
tmp_fd = mkstemp(tmp_proxy);
if (tmp_fd == -1) {
- edg_wlpr_Log(LOG_ERR, "Cannot create temporary file (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot create temporary file (%s)",
strerror(errno));
return errno;
}
- ret = get_proxy_base_name(current_proxy, &client_request->username);
+ ret = get_proxy_base_name(ctx, current_proxy, &client_request->username);
if (ret)
goto end;
server = (myproxy_server) ? myproxy_server : socket_attrs->pshost;
if (server == NULL) {
- edg_wlpr_Log(LOG_ERR, "No myproxy server specified");
+ edg_wlpr_Log(ctx, LOG_ERR, "No myproxy server specified");
ret = EINVAL;
goto end;
}
server_response, tmp_proxy);
if (ret == 1) {
ret = EDG_WLPR_ERROR_MYPROXY;
- edg_wlpr_Log(LOG_ERR, "Error contacting MyProxy server for proxy %s: %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Error contacting MyProxy server for proxy %s: %s",
current_proxy, verror_get_string());
verror_clear();
goto end;
renewed_proxy = tmp_proxy;
- if (context->voms_enabled && voms_exts) {
+ if (ctx->voms_enabled && voms_exts) {
char tmp_voms_proxy[FILENAME_MAX];
int tmp_voms_fd;
current_proxy);
tmp_voms_fd = mkstemp(tmp_voms_proxy);
if (tmp_voms_fd == -1) {
- edg_wlpr_Log(LOG_ERR, "Cannot create temporary file (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot create temporary file (%s)",
strerror(errno));
ret = errno;
goto end;
}
- ret = renew_voms_creds(current_proxy, renewed_proxy, tmp_voms_proxy);
+ ret = renew_voms_creds(ctx, current_proxy, renewed_proxy, tmp_voms_proxy);
close(tmp_voms_fd);
if (ret) {
unlink(tmp_voms_proxy);
/* XXX remove these ugly things: */
void
-edg_wlpr_Log(int dbg_level, const char *format, ...)
+edg_wlpr_Log(glite_renewal_core_context context, int dbg_level, const char *format, ...)
{
return;
}
typedef struct {
edg_wlpr_Command code;
- void (*handler) (edg_wlpr_Request *request, edg_wlpr_Response *response);
+ void (*handler) (glite_renewal_core_context ctx, edg_wlpr_Request *request, edg_wlpr_Response *response);
} command_table;
static command_table commands[] = {
/* static prototypes */
static void
-usage(char *progname);
+usage(glite_renewal_core_context ctx, char *progname);
static int
-do_listen(char *socket_name, int *sock);
+do_listen(glite_renewal_core_context ctx, char *socket_name, int *sock);
static int
-encode_response(edg_wlpr_Response *response, char **msg);
+encode_response(glite_renewal_core_context ctx, edg_wlpr_Response *response, char **msg);
static command_table *
-find_command(edg_wlpr_Command code);
+find_command(glite_renewal_core_context ctx, edg_wlpr_Command code);
static int
-proto(int sock);
+proto(glite_renewal_core_context ctx, int sock);
static int
-doit(int sock);
+doit(glite_renewal_core_context ctx, int sock);
static int
-decode_request(const char *msg, const size_t msg_len, edg_wlpr_Request *request);
+decode_request(glite_renewal_core_context ctx, const char *msg, const size_t msg_len, edg_wlpr_Request *request);
int
-start_watchdog(pid_t *pid);
+start_watchdog(glite_renewal_core_context ctx, pid_t *pid);
static void
catchsig(int sig)
}
static command_table *
-find_command(edg_wlpr_Command code)
+find_command(glite_renewal_core_context ctx, edg_wlpr_Command code)
{
command_table *c;
}
static int
-proto(int sock)
+proto(glite_renewal_core_context ctx, int sock)
{
char *buf = NULL;
size_t buf_len;
ret = edg_wlpr_Read(sock, &timeout, &buf, &buf_len);
if (ret) {
- edg_wlpr_Log(LOG_ERR, "Error reading from client: %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Error reading from client: %s",
edg_wlpr_GetErrorString(ret));
return ret;
}
- ret = decode_request(buf, buf_len, &request);
+ ret = decode_request(ctx, buf, buf_len, &request);
free(buf);
if (ret)
goto end;
/* XXX check request (protocol version, ...) */
- command = find_command(request.command);
+ command = find_command(ctx, request.command);
if (command == NULL) {
ret = EDG_WLPR_ERROR_UNKNOWN_COMMAND;
- edg_wlpr_Log(LOG_ERR, "Received unknown command (%d)", request.command);
+ edg_wlpr_Log(ctx, LOG_ERR, "Received unknown command (%d)", request.command);
goto end;
}
- edg_wlpr_Log(LOG_INFO, "Received command code %d for proxy %s and jobid %s",
+ edg_wlpr_Log(ctx, LOG_INFO, "Received command code %d for proxy %s and jobid %s",
request.command,
request.proxy_filename ? request.proxy_filename : "(unspecified)",
request.jobid ? request.jobid : "(unspecified)");
- command->handler(&request, &response);
+ command->handler(ctx, &request, &response);
- ret = encode_response(&response, &buf);
+ ret = encode_response(ctx, &response, &buf);
if (ret)
goto end;
ret = edg_wlpr_Write(sock, &timeout, buf, strlen(buf) + 1);
free(buf);
if (ret) {
- edg_wlpr_Log(LOG_ERR, "Error sending response to client: %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Error sending response to client: %s",
edg_wlpr_GetErrorString(ret));
goto end;
}
}
static int
-doit(int sock)
+doit(glite_renewal_core_context ctx, int sock)
{
int newsock;
struct sockaddr_un client_addr;
while ((pid=waitpid(-1,NULL,WNOHANG))>0)
;
- ret = start_watchdog(&newpid);
+ ret = start_watchdog(ctx, &newpid);
if (ret)
return ret;
- edg_wlpr_Log(LOG_DEBUG, "Renewal slave process re-started");
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Renewal slave process re-started");
child_died = 0;
continue;
}
newsock = accept(sock, (struct sockaddr *) &client_addr, &client_addr_len);
if (newsock == -1) {
if (errno != EINTR)
- edg_wlpr_Log(LOG_ERR, "accept() failed");
+ edg_wlpr_Log(ctx, LOG_ERR, "accept() failed");
continue;
}
- edg_wlpr_Log(LOG_DEBUG, "Got connection");
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Got connection");
flags = fcntl(newsock, F_GETFL, 0);
if (fcntl(newsock, F_SETFL, flags | O_NONBLOCK) < 0) {
- edg_wlpr_Log(LOG_ERR, "Can't set O_NONBLOCK mode (%s), closing.\n",
+ edg_wlpr_Log(ctx, LOG_ERR, "Can't set O_NONBLOCK mode (%s), closing.\n",
strerror(errno));
close(newsock);
continue;
}
- proto(newsock);
+ proto(ctx, newsock);
- edg_wlpr_Log(LOG_DEBUG, "Connection closed");
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Connection closed");
close(newsock);
}
- edg_wlpr_Log(LOG_DEBUG, "Terminating on signal %d\n",die);
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Terminating on signal %d\n",die);
return 0;
}
static int
-decode_request(const char *msg, const size_t msg_len, edg_wlpr_Request *request)
+decode_request(glite_renewal_core_context ctx, const char *msg, const size_t msg_len, edg_wlpr_Request *request)
{
char *value = NULL;
#if 0
ret = edg_wlpr_GetToken(msg, msg_len, EDG_WLPR_PROTO_VERSION, SEPARATORS,
0, &request->version);
if (ret) {
- edg_wlpr_Log(LOG_ERR, "Protocol error reading protocol specification: %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Protocol error reading protocol specification: %s",
edg_wlpr_GetErrorString(ret));
return ret;
}
ret = edg_wlpr_GetToken(msg, msg_len, EDG_WLPR_PROTO_COMMAND, SEPARATORS,
0, &value);
if (ret) {
- edg_wlpr_Log(LOG_ERR, "Protocol error reading command specification: %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Protocol error reading command specification: %s",
edg_wlpr_GetErrorString(ret));
goto err;
}
ret = edg_wlpr_DecodeInt(value, (int *)(&request->command));
if (ret) {
- edg_wlpr_Log(LOG_ERR, "Received non-numeric command specification (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Received non-numeric command specification (%s)",
value);
free(value);
goto err;
}
free(value);
- if (find_command(request->command) == NULL) {
- edg_wlpr_Log(LOG_ERR, "Received unknown command (%d)", request->command);
+ if (find_command(ctx, request->command) == NULL) {
+ edg_wlpr_Log(ctx, LOG_ERR, "Received unknown command (%d)", request->command);
ret = EDG_WLPR_ERROR_UNKNOWN_COMMAND;
goto err;
}
ret = edg_wlpr_GetToken(msg, msg_len, EDG_WLPR_PROTO_MYPROXY_SERVER,
SEPARATORS, 0, &request->myproxy_server);
if (ret && ret != EDG_WLPR_ERROR_PROTO_PARSE_NOT_FOUND) {
- edg_wlpr_Log(LOG_ERR, "Protocol error reading myproxy server specification: %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Protocol error reading myproxy server specification: %s",
edg_wlpr_GetErrorString(ret));
goto err;
}
ret = edg_wlpr_GetToken(msg, msg_len, EDG_WLPR_PROTO_PROXY, SEPARATORS,
0, &request->proxy_filename);
if (ret && ret != EDG_WLPR_ERROR_PROTO_PARSE_NOT_FOUND) {
- edg_wlpr_Log(LOG_ERR, "Protocol error reading proxy specification: %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Protocol error reading proxy specification: %s",
edg_wlpr_GetErrorString(ret));
goto err;
}
ret = edg_wlpr_GetToken(msg, msg_len, EDG_WLPR_PROTO_JOBID, SEPARATORS,
0, &request->jobid);
if (ret && ret != EDG_WLPR_ERROR_PROTO_PARSE_NOT_FOUND) {
- edg_wlpr_Log(LOG_ERR, "Protocol error reading JobId : %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "Protocol error reading JobId : %s",
edg_wlpr_GetErrorString(ret));
goto err;
}
}
static int
-encode_response(edg_wlpr_Response *response, char **msg)
+encode_response(glite_renewal_core_context ctx, edg_wlpr_Response *response, char **msg)
{
char *buf;
size_t buf_len;
static void
-usage(char *progname)
+usage(glite_renewal_core_context ctx, char *progname)
{
fprintf(stderr,"usage: %s [option]\n"
"\t-h, --help display this help and exit\n"
}
static int
-do_listen(char *socket_name, int *sock)
+do_listen(glite_renewal_core_context ctx, char *socket_name, int *sock)
{
struct sockaddr_un my_addr;
int s;
s = socket(AF_UNIX, SOCK_STREAM, 0);
if (s == -1) {
- edg_wlpr_Log(LOG_ERR, "socket(): %s", strerror(errno));
+ edg_wlpr_Log(ctx, LOG_ERR, "socket(): %s", strerror(errno));
return errno;
}
ret = bind(s, (struct sockaddr *)&my_addr, sizeof(my_addr));
if (ret == -1) {
- edg_wlpr_Log(LOG_ERR, "bind(): %s", strerror(errno));
+ edg_wlpr_Log(ctx, LOG_ERR, "bind(): %s", strerror(errno));
close(s);
return errno;
}
ret = listen(s, 50);
if (ret == -1) {
- edg_wlpr_Log(LOG_ERR, "listen(): %s", strerror(errno));
+ edg_wlpr_Log(ctx, LOG_ERR, "listen(): %s", strerror(errno));
close(s);
return errno;
}
}
void
-edg_wlpr_Log(int dbg_level, const char *format, ...)
+edg_wlpr_Log(glite_renewal_core_context ctx, int dbg_level, const char *format, ...)
{
va_list ap;
char log_mess[1024];
}
int
-start_watchdog(pid_t *pid)
+start_watchdog(glite_renewal_core_context ctx, pid_t *pid)
{
pid_t p;
switch ((p = fork())) {
case -1:
- edg_wlpr_Log(LOG_ERR, "fork() failed: %s",
+ edg_wlpr_Log(ctx, LOG_ERR, "fork() failed: %s",
strerror(errno));
return errno;
case 0:
- watchdog_start();
+ watchdog_start(ctx);
exit(0);
break;
default:
pid_t pid;
struct sigaction sa;
const char *s = NULL;
+ glite_renewal_core_context ctx = NULL;
progname = strrchr(argv[0],'/');
if (progname) progname++;
while ((opt = getopt_long(argc, argv, "hvdr:c:C:V:AG:t:k:", opts, NULL)) != EOF)
switch (opt) {
- case 'h': usage(progname); exit(0);
+ case 'h': usage(ctx, progname); exit(0);
case 'v': fprintf(stdout, "%s:\t%s\n", progname, rcsid); exit(0);
case 'd': debug = 1; break;
case 'r': repository = optarg; break;
case 'G': vomsconf = optarg; break;
case 't': cert = optarg; break;
case 'k': key = optarg; break;
- case '?': usage(progname); return 1;
+ case '?': usage(ctx, progname); return 1;
}
if (optind < argc) {
- usage(progname);
+ usage(ctx, progname);
exit(1);
}
if (chdir(repository)) {
- edg_wlpr_Log(LOG_ERR, "Cannot access repository directory %s (%s)",
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot access repository directory %s (%s)",
repository, strerror(errno));
exit(1);
}
sigaction(SIGCHLD,&sa,NULL);
sigaction(SIGPIPE,&sa,NULL);
- ret = start_watchdog(&pid);
+ ret = start_watchdog(ctx, &pid);
if (ret)
return 1;
snprintf(sockname, sizeof(sockname), "%s%d",
DGPR_REG_SOCKET_NAME_ROOT, getuid());
/* XXX check that the socket is not already active */
- ret = do_listen(sockname, &sock);
+ ret = do_listen(ctx, sockname, &sock);
if (ret)
return 1;
- edg_wlpr_Log(LOG_DEBUG, "Listening at %s", sockname);
+ edg_wlpr_Log(ctx, LOG_DEBUG, "Listening at %s", sockname);
- ret = doit(sock);
+ ret = doit(ctx, sock);
close(sock);
return ret;
}
+/* XXX remove once the renew_core libs is used */
+#if 1
int
-get_proxy_base_name(char *file, char **name)
+get_proxy_base_name(glite_renewal_core_context ctx, char *file, char **name)
{
X509 *cert = NULL;
EVP_PKEY *key = NULL;
X509_NAME *subject = NULL;
int ret;
- ret = load_proxy(file, &cert, &key, &chain, NULL);
+ ret = load_proxy(ctx, file, &cert, &key, &chain, NULL);
if (ret)
return ret;
ret = globus_gsi_cert_utils_get_base_name(subject, chain);
if (ret) {
- edg_wlpr_Log(LOG_ERR, "Cannot get subject name from proxy %s", file);
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot get subject name from proxy %s", file);
ret = EDG_WLPR_ERROR_SSL; /* XXX ??? */
goto end;
}
return ret;
}
+#endif
#include <globus_gsi_cert_utils_constants.h>
#include "renewal.h"
+#include "renewal_core.h"
#ifdef HAVE_DMALLOC_H
#include <dmalloc.h>
/* commands */
void
-register_proxy(edg_wlpr_Request *request, edg_wlpr_Response *response);
+register_proxy(glite_renewal_core_context ctx, edg_wlpr_Request *request, edg_wlpr_Response *response);
void
-unregister_proxy(edg_wlpr_Request *request, edg_wlpr_Response *response);
+unregister_proxy(glite_renewal_core_context ctx, edg_wlpr_Request *request, edg_wlpr_Response *response);
void
-get_proxy(edg_wlpr_Request *request, edg_wlpr_Response *response);
+get_proxy(glite_renewal_core_context ctx, edg_wlpr_Request *request, edg_wlpr_Response *response);
void
-update_db(edg_wlpr_Request *request, edg_wlpr_Response *response);
+update_db(glite_renewal_core_context ctx, edg_wlpr_Request *request, edg_wlpr_Response *response);
int
-get_times(char *proxy_file, proxy_record *record);
+get_times(glite_renewal_core_context ctx, char *proxy_file, proxy_record *record);
void
-watchdog_start(void);
+watchdog_start(glite_renewal_core_context ctx);
void
-edg_wlpr_Log(int dbg_level, const char *format, ...);
+edg_wlpr_Log(glite_renewal_core_context ctx, int dbg_level, const char *format, ...);
int
-decode_record(char *line, proxy_record *record);
+decode_record(glite_renewal_core_context ctx, char *line, proxy_record *record);
int
-encode_record(proxy_record *record, char **line);
+encode_record(glite_renewal_core_context ctx, proxy_record *record, char **line);
void
-free_record(proxy_record *record);
+free_record(glite_renewal_core_context ctx, proxy_record *record);
int
-load_proxy(const char *filename, X509 **cert, EVP_PKEY **privkey,
+load_proxy(glite_renewal_core_context ctx, const char *filename, X509 **cert, EVP_PKEY **privkey,
STACK_OF(X509) **chain, globus_gsi_cred_handle_t *proxy);
int
-get_proxy_base_name(char *file, char **subject);
+get_proxy_base_name(glite_renewal_core_context ctx, char *file, char **subject);
int
-renew_voms_creds(const char *cur_file, const char *renewed_file, const char *new_file);
+renew_voms_creds(glite_renewal_core_context ctx, const char *cur_file, const char *renewed_file, const char *new_file);
#endif /* RENEWALD_LOCL_H */
extern char *vomsconf;
static int
-generate_proxy(globus_gsi_cred_handle_t cur_proxy,
+generate_proxy(glite_renewal_core_context ctx, globus_gsi_cred_handle_t cur_proxy,
X509_EXTENSION *voms_extension, const char *new_file)
{
globus_result_t result;
result = globus_gsi_proxy_handle_init(&proxy_handle, NULL);
if (result) {
- edg_wlpr_Log(LOG_ERR, "globus_gsi_proxy_handle_init() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "globus_gsi_proxy_handle_init() failed\n");
goto end;
}
result = globus_gsi_cred_get_key(cur_proxy, &cur_proxy_priv_key);
if (result) {
- edg_wlpr_Log(LOG_ERR, "globus_gsi_cred_get_key() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "globus_gsi_cred_get_key() failed\n");
goto end;
}
/* Create and sign a new proxy */
result = globus_gsi_cred_get_cert_type(cur_proxy, &proxy_type);
if (result) {
- edg_wlpr_Log(LOG_ERR, "globus_gsi_cred_get_cert_type() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "globus_gsi_cred_get_cert_type() failed\n");
goto end;
}
result = globus_gsi_proxy_handle_set_type(proxy_handle, proxy_type);
if (result) {
- edg_wlpr_Log(LOG_ERR, "globus_gsi_proxy_handle_set_type() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "globus_gsi_proxy_handle_set_type() failed\n");
goto end;
}
result = globus_gsi_proxy_create_signed(proxy_handle, cur_proxy, &proxy);
if (result) {
- edg_wlpr_Log(LOG_ERR, "globus_gsi_proxy_handle_init() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "globus_gsi_proxy_handle_init() failed\n");
goto end;
}
/* Get the new proxy */
result = globus_gsi_cred_get_cert(proxy, &new_cert);
if (result) {
- edg_wlpr_Log(LOG_ERR, "globus_gsi_cred_get_cert() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "globus_gsi_cred_get_cert() failed\n");
goto end;
}
/* And put the cert back, older one is unallocated by the function */
result = globus_gsi_cred_set_cert(proxy, voms_cert);
if (result) {
- edg_wlpr_Log(LOG_ERR, "globus_gsi_cred_set_cert() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "globus_gsi_cred_set_cert() failed\n");
goto end;
}
}
static int
-my_VOMS_Export(void *buf, int buf_len, X509_EXTENSION **extension)
+my_VOMS_Export(glite_renewal_core_context ctx, void *buf, int buf_len, X509_EXTENSION **extension)
{
AC *ac = NULL;
unsigned char *p, *pp;
p = pp = buf;
ac = d2i_AC(NULL, &p, buf_len+1);
if (ac == NULL) {
- edg_wlpr_Log(LOG_ERR, "d2i_AC() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "d2i_AC() failed\n");
return 1;
}
}
static int
-create_voms_command(struct vomsdata *vd, struct voms **voms_cert, char **command)
+create_voms_command(glite_renewal_core_context ctx, struct vomsdata *vd, struct voms **voms_cert, char **command)
{
int voms_error, ret;
struct data **attribs;
for (i = 2; i < argc; i++) {
ret = VOMS_Ordering(argv[i], vd, &voms_error);
if (ret == 0) {
- edg_wlpr_Log(LOG_ERR, "VOMS_Ordering() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "VOMS_Ordering() failed\n");
return 1;
}
}
#endif
if (voms_cert == NULL || *voms_cert == NULL || (*voms_cert)->std == NULL) {
- edg_wlpr_Log(LOG_ERR, "Invalid VOMS certificate\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "Invalid VOMS certificate\n");
return 1;
}
}
static int
-renew_voms_cert(struct vomsdata *vd, struct voms **voms_cert,
+renew_voms_cert(glite_renewal_core_context ctx, struct vomsdata *vd, struct voms **voms_cert,
char **buf, size_t *buf_len)
{
int voms_error = 0, i, ret, voms_version;
voms_contacts = VOMS_FindByVO(vd, (*voms_cert)->voname, vomsconf, NULL, &voms_error);
if (voms_contacts == NULL) {
- edg_wlpr_Log(LOG_ERR, "VOMS_FindByVO() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "VOMS_FindByVO() failed\n");
return 1;
}
- ret = create_voms_command(vd, voms_cert, &command);
+ ret = create_voms_command(ctx, vd, voms_cert, &command);
/* XXX iterate over all servers on the list on errors */
ret = VOMS_ContactRaw(voms_contacts[0]->host, voms_contacts[0]->port,
(void**) buf, buf_len, &voms_version,
vd, &voms_error);
if (ret == 0) {
- edg_wlpr_Log(LOG_ERR, "VOMS_Contact() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "VOMS_Contact() failed\n");
return 1;
}
}
static int
-renew_voms_certs(const char *cur_file, const char *renewed_file, const char *new_file)
+renew_voms_certs(glite_renewal_core_context ctx, const char *cur_file, const char *renewed_file, const char *new_file)
{
globus_gsi_cred_handle_t cur_proxy = NULL;
globus_gsi_cred_handle_t new_proxy = NULL;
setenv("X509_USER_CERT", renewed_file, 1);
setenv("X509_USER_KEY", renewed_file, 1);
- ret = load_proxy(cur_file, &cert, NULL, &chain, &cur_proxy);
+ ret = load_proxy(ctx, cur_file, &cert, NULL, &chain, &cur_proxy);
if (ret)
goto end;
vd = VOMS_Init(NULL, NULL);
if (vd == NULL) {
- edg_wlpr_Log(LOG_ERR, "VOMS_Init() failed\n");
+ edg_wlpr_Log(ctx, LOG_ERR, "VOMS_Init() failed\n");
return 1;
}
/* no VOMS cred, no problem; continue */
/* XXX this part shouldn't be reachable, this call is only called
* if the proxy does contain VOMS attributes */
- edg_wlpr_Log(LOG_ERR, "No VOMS attributes found in proxy %s\n", cur_file);
+ edg_wlpr_Log(ctx, LOG_ERR, "No VOMS attributes found in proxy %s\n", cur_file);
ret = 0;
goto end;
} else {
- edg_wlpr_Log(LOG_ERR, "Cannot get VOMS certificate(s) from proxy");
+ edg_wlpr_Log(ctx, LOG_ERR, "Cannot get VOMS certificate(s) from proxy");
ret = 1;
goto end;
}
char *tmp, *ptr;
size_t tmp_len;
- ret = renew_voms_cert(vd, voms_cert, &tmp, &tmp_len);
+ ret = renew_voms_cert(ctx, vd, voms_cert, &tmp, &tmp_len);
if (ret)
goto end;
ptr = realloc(buf, buf_len + tmp_len);
goto end;
}
- ret = my_VOMS_Export(buf, buf_len, &extension);
+ ret = my_VOMS_Export(ctx, buf, buf_len, &extension);
if (ret)
goto end;
- ret = load_proxy(renewed_file, NULL, NULL, NULL, &new_proxy);
+ ret = load_proxy(ctx, renewed_file, NULL, NULL, NULL, &new_proxy);
if (ret)
goto end;
- ret = generate_proxy(new_proxy, extension, new_file);
+ ret = generate_proxy(ctx, new_proxy, extension, new_file);
end:
(old_env_proxy) ? setenv("X509_USER_PROXY", old_env_proxy, 1) :
}
int
-renew_voms_creds(const char *cur_file, const char *renewed_file, const char *new_file)
+renew_voms_creds(glite_renewal_core_context ctx, const char *cur_file, const char *renewed_file, const char *new_file)
{
- return renew_voms_certs(cur_file, renewed_file, new_file);
+ return renew_voms_certs(ctx, cur_file, renewed_file, new_file);
}
#if 0
if (globus_module_activate(GLOBUS_GSI_PROXY_MODULE) != GLOBUS_SUCCESS ||
globus_module_activate(GLOBUS_GSI_CERT_UTILS_MODULE) != GLOBUS_SUCCESS) {
- edg_wlpr_Log(LOG_ERR, "[%d]: Unable to initialize Globus modules\n", getpid());
+ edg_wlpr_Log(ctx, LOG_ERR, "[%d]: Unable to initialize Globus modules\n", getpid());
return 1;
}
git://scientific.zcu.cz / jra1mw.git / commitdiff