*----------------------------------------------------------------------
*
* handle_signal -
- * USR1 - increase the verbosity of the program
- * USR2 - decrease the verbosity of the program
+ * HUP - reread log4crc
+ * USR1 - set all priorities to DEBUG
+ * USR2 - set all priorities back to initial values
*
*----------------------------------------------------------------------
*/
void handle_signal(int num) {
- if (num != SIGCHLD) edg_wll_ll_log(LOG_NOTICE,"Received signal %d\n", num);
+ if (num != SIGCHLD) glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_INFO,"Received signal %d\n", num);
switch (num) {
- case SIGUSR1:
- if (edg_wll_ll_log_level < LOG_DEBUG) edg_wll_ll_log_level++;
- edg_wll_ll_log(LOG_NOTICE,"Logging level is now %d\n", edg_wll_ll_log_level);
- break;
- case SIGUSR2:
- if (edg_wll_ll_log_level > LOG_EMERG) edg_wll_ll_log_level--;
- edg_wll_ll_log(LOG_NOTICE,"Logging level is now %d\n", edg_wll_ll_log_level);
- break;
- case SIGPIPE:
- edg_wll_ll_log(LOG_NOTICE,"Broken pipe, lost communication channel.\n");
- break;
- case SIGCHLD:
- while (wait3(NULL,WNOHANG,NULL) > 0);
- break;
- case SIGINT:
- case SIGTERM:
- case SIGQUIT:
- if (confirm_sock) {
- edg_wll_ll_log(LOG_NOTICE,"Closing confirmation socket.\n");
- close(confirm_sock);
- unlink(confirm_sock_name);
- }
- exit(1);
- break;
- default: break;
+ case SIGHUP:
+ log4c_reread();
+ glite_common_log_priority_security = log4c_category_get_priority(log4c_category_get(LOG_CATEGORY_SECURITY));
+ glite_common_log_priority_access = log4c_category_get_priority(log4c_category_get(LOG_CATEGORY_ACCESS));
+ glite_common_log_priority_control = log4c_category_get_priority(log4c_category_get(LOG_CATEGORY_CONTROL));
+ /* TODO: probably also restart parent logd process? */
+ break;
+ case SIGUSR1:
+ log4c_category_set_priority(log4c_category_get(LOG_CATEGORY_SECURITY),LOG_PRIORITY_DEBUG);
+ log4c_category_set_priority(log4c_category_get(LOG_CATEGORY_ACCESS),LOG_PRIORITY_DEBUG);
+ log4c_category_set_priority(log4c_category_get(LOG_CATEGORY_CONTROL),LOG_PRIORITY_DEBUG);
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_INFO,
+ "Logging priority is now %s\n", log4c_priority_to_string(LOG_PRIORITY_DEBUG));
+ break;
+ case SIGUSR2:
+ log4c_category_set_priority(log4c_category_get(LOG_CATEGORY_SECURITY),glite_common_log_priority_security);
+ log4c_category_set_priority(log4c_category_get(LOG_CATEGORY_ACCESS),glite_common_log_priority_access);
+ log4c_category_set_priority(log4c_category_get(LOG_CATEGORY_CONTROL),glite_common_log_priority_control);
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_INFO,
+ "Logging priority is now %s for %s, %s for %s and %s for %s\n",
+ log4c_priority_to_string(glite_common_log_priority_security),LOG_CATEGORY_SECURITY,
+ log4c_priority_to_string(glite_common_log_priority_access),LOG_CATEGORY_ACCESS,
+ log4c_priority_to_string(glite_common_log_priority_control),LOG_CATEGORY_CONTROL);
+ break;
+ case SIGPIPE:
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_INFO,"Broken pipe, lost communication channel.\n");
+ break;
+ case SIGCHLD:
+ while (wait3(NULL,WNOHANG,NULL) > 0);
+ break;
+ case SIGINT:
+ case SIGTERM:
+ case SIGQUIT:
+ if (confirm_sock) {
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_INFO,"Closing confirmation socket.\n");
+ close(confirm_sock);
+ unlink(confirm_sock_name);
+ }
+ exit(1);
+ break;
+ default: break;
}
}
timeout.tv_sec = ACCEPT_TIMEOUT;
timeout.tv_usec = 0;
getpeername(socket,(struct sockaddr *) &peer,&alen);
- edg_wll_ll_log(LOG_DEBUG,"Accepting connection (remaining timeout %d.%06d sec)\n",
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Accepting connection (remaining timeout %d.%06d sec)\n",
(int)timeout.tv_sec, (int) timeout.tv_usec);
if ((ret = edg_wll_gss_accept(cred_handle,socket,&timeout,&con, &gss_stat)) < 0) {
- edg_wll_ll_log(LOG_DEBUG,"timeout after gss_accept is %d.%06d sec\n",
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"timeout after gss_accept is %d.%06d sec\n",
(int)timeout.tv_sec, (int) timeout.tv_usec);
- edg_wll_ll_log(LOG_ERR,"%s: edg_wll_gss_accept() failed\n",inet_ntoa(peer.sin_addr));
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"%s: edg_wll_gss_accept() failed\n",inet_ntoa(peer.sin_addr));
return edg_wll_log_proto_server_failure(ret,&gss_stat,"edg_wll_gss_accept() failed\n");
}
/* authenticate */
- edg_wll_ll_log(LOG_INFO,"Processing authentication:\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Processing authentication:\n");
ret = edg_wll_gss_get_client_conn(&con, &client, &gss_stat);
if (ret) {
char *gss_err;
edg_wll_gss_get_error(&gss_stat, "Cannot read client identification", &gss_err);
- edg_wll_ll_log(LOG_WARNING, "%s: %s\n", inet_ntoa(peer.sin_addr),gss_err);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_WARN, "%s: %s\n", inet_ntoa(peer.sin_addr),gss_err);
free(gss_err);
}
if (ret || client->flags & EDG_WLL_GSS_FLAG_ANON) {
- edg_wll_ll_log(LOG_INFO," User not authenticated, setting as \"%s\". \n",EDG_WLL_LOG_USER_DEFAULT);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO," User not authenticated, setting as \"%s\". \n",EDG_WLL_LOG_USER_DEFAULT);
subject=strdup(EDG_WLL_LOG_USER_DEFAULT);
} else {
- edg_wll_ll_log(LOG_INFO," User successfully authenticated as:\n");
- edg_wll_ll_log(LOG_INFO, " %s\n", client->name);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO," User successfully authenticated as:\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO, " %s\n", client->name);
subject=strdup(client->name);
}
if (client)
while (timeout.tv_sec > 0) {
count++;
- edg_wll_ll_log(LOG_DEBUG,"Waiting for data delivery no. %d (remaining timeout %d.%06d sec)\n",
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Waiting for data delivery no. %d (remaining timeout %d.%06d sec)\n",
count, (int)timeout.tv_sec, (int) timeout.tv_usec);
FD_SET(con.sock,&fdset);
fd = select(con.sock+1,&fdset,NULL,NULL,&timeout);
switch (fd) {
case 0: /* timeout */
- edg_wll_ll_log(LOG_DEBUG,"Connection timeout expired\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Connection timeout expired\n");
timeout.tv_sec = 0;
break;
case -1: /* error */
switch(errno) {
case EINTR:
- edg_wll_ll_log(LOG_DEBUG,"XXX: Waking up (remaining timeout %d.%06d sec)\n",
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"XXX: Waking up (remaining timeout %d.%06d sec)\n",
(int)timeout.tv_sec, (int) timeout.tv_usec);
continue;
default:
}
break;
default:
- edg_wll_ll_log(LOG_DEBUG,"Waking up (remaining timeout %d.%06d sec)\n",
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Waking up (remaining timeout %d.%06d sec)\n",
(int)timeout.tv_sec, (int) timeout.tv_usec);
break;
}
if (FD_ISSET(con.sock,&fdset)) {
ret = edg_wll_log_proto_server(&con,&timeout,subject,file_name_prefix,noipc,noparse);
if (ret != 0) {
- edg_wll_ll_log(LOG_DEBUG,"timeout after edg_wll_log_proto_server is %d.%06d sec\n",
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"timeout after edg_wll_log_proto_server is %d.%06d sec\n",
(int)timeout.tv_sec, (int) timeout.tv_usec);
if (ret != EDG_WLL_GSS_ERROR_EOF)
- edg_wll_ll_log(LOG_ERR,"edg_wll_log_proto_server(): Error\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_log_proto_server(): Error\n");
else if (count == 1)
- edg_wll_ll_log(LOG_ERR,"edg_wll_log_proto_server(): Error. EOF occured.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_log_proto_server(): Error. EOF occured.\n");
timeout.tv_sec = 0;
timeout.tv_usec = 0;
break;
}
doit_end:
- edg_wll_ll_log(LOG_DEBUG, "Closing descriptor '%d'...",con.sock);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG, "Closing descriptor '%d'...",con.sock);
edg_wll_gss_close(&con, NULL);
if (con.sock == -1)
- edg_wll_ll_log(LOG_DEBUG, "o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG, "o.k.\n");
if (subject) free(subject);
return ret;
}
usage(argv[0]); exit(0);
}
}
+ if (debug) {
+ glite_common_log_init(LOG_PRIORITY_DEBUG);
+ } else {
#ifdef LB_PERF
- edg_wll_ll_log_init(verbose ? LOG_INFO : LOG_ERR);
+ glite_common_log_init(verbose ? LOG_PRIORITY_INFO : LOG_PRIORITY_NOTSET);
#else
- edg_wll_ll_log_init(verbose ? LOG_DEBUG : LOG_INFO);
+ glite_common_log_init(verbose ? LOG_PRIORITY_DEBUG : LOG_PRIORITY_NOTSET);
#endif
- edg_wll_ll_log(LOG_INFO,"Initializing...\n");
+ }
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_INFO,"Initializing...\n");
/* check noParse */
if (noParse) {
- edg_wll_ll_log(LOG_INFO,"Parse messages for correctness... [no]\n");
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_INFO,"Parse messages for correctness... [no]\n");
} else {
- edg_wll_ll_log(LOG_INFO,"Parse messages for correctness... [yes]\n");
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_INFO,"Parse messages for correctness... [yes]\n");
}
/* check noIPC */
if (noIPC) {
- edg_wll_ll_log(LOG_INFO,"Send messages also to inter-logger... [no]\n");
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_INFO,"Send messages also to inter-logger... [no]\n");
} else {
- edg_wll_ll_log(LOG_INFO,"Send messages also to inter-logger... [yes]\n");
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_INFO,"Send messages also to inter-logger... [yes]\n");
}
/* check prefix correctness */
if (strlen(prefix) > FILENAME_MAX - 34) {
- edg_wll_ll_log(LOG_CRIT,"Too long prefix (%s) for file names, would not be able to write to log files. Exiting.\n",prefix);
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_FATAL,"Too long prefix (%s) for file names, would not be able to write to log files. Exiting.\n",prefix);
exit(1);
}
/* TODO: check for write permisions */
- edg_wll_ll_log(LOG_INFO,"Messages will be stored with the filename prefix \"%s\".\n",prefix);
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_INFO,"Messages will be stored with the filename prefix \"%s\".\n",prefix);
if (CAcert_dir)
setenv("X509_CERT_DIR", CAcert_dir, 1);
if (mysignal(SIGUSR1, handle_signal) == SIG_ERR) { perror("signal"); exit(1); }
if (mysignal(SIGUSR2, handle_signal) == SIG_ERR) { perror("signal"); exit(1); }
if (mysignal(SIGPIPE, handle_signal) == SIG_ERR) { perror("signal"); exit(1); }
- if (mysignal(SIGHUP, SIG_DFL) == SIG_ERR) { perror("signal"); exit(1); }
+ if (mysignal(SIGHUP, handle_signal) == SIG_ERR) { perror("signal"); exit(1); }
if (mysignal(SIGINT, handle_signal) == SIG_ERR) { perror("signal"); exit(1); }
if (mysignal(SIGQUIT, handle_signal) == SIG_ERR) { perror("signal"); exit(1); }
if (mysignal(SIGTERM, handle_signal) == SIG_ERR) { perror("signal"); exit(1); }
ret = edg_wll_gss_acquire_cred_gsi(cert_file, key_file, &cred, &gss_stat);
if (ret) {
/* XXX DK: call edg_wll_gss_get_error() */
- edg_wll_ll_log(LOG_CRIT,"Failed to get GSI credentials. Exiting.\n");
+ glite_common_log(LOG_CATEGORY_CONTROL,LOG_PRIORITY_FATAL,"Failed to get GSI credentials. Exiting.\n");
exit(1);
}
if (cred->name!=NULL) {
- edg_wll_ll_log(LOG_INFO,"Server running with certificate: %s\n",cred->name);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Server running with certificate: %s\n",cred->name);
} else if (noAuth) {
- edg_wll_ll_log(LOG_INFO,"Server running without certificate\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Server running without certificate\n");
}
/* do listen */
- edg_wll_ll_log(LOG_INFO,"Listening on port %d\n",port);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Listening on port %d\n",port);
listener_fd = do_listen(port);
if (listener_fd == -1) {
- edg_wll_ll_log(LOG_CRIT,"Failed to listen on port %d\n",port);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_FATAL,"Failed to listen on port %d\n",port);
edg_wll_gss_release_cred(&cred, NULL);
exit(-1);
} else {
- edg_wll_ll_log(LOG_DEBUG,"Listener's socket descriptor is '%d'\n",listener_fd);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Listener's socket descriptor is '%d'\n",listener_fd);
}
client_addr_len = sizeof(client_addr);
/* daemonize */
if (debug) {
- edg_wll_ll_log(LOG_INFO,"Running as daemon... [no]\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Running as daemon... [no]\n");
} else {
- edg_wll_ll_log(LOG_INFO,"Running as daemon... [yes]\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Running as daemon... [yes]\n");
if (daemon(0,0) < 0) {
- edg_wll_ll_log(LOG_CRIT,"Failed to run as daemon. Exiting.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_FATAL,"Failed to run as daemon. Exiting.\n");
SYSTEM_ERROR("daemon");
exit(1);
}
while (1) {
int opt;
- edg_wll_ll_log(LOG_INFO,"Accepting incomming connections...\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Accepting incomming connections...\n");
client_fd = accept(listener_fd, (struct sockaddr *) &client_addr,
&client_addr_len);
if (client_fd < 0) {
close(listener_fd);
- edg_wll_ll_log(LOG_CRIT,"Failed to accept incomming connections\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_FATAL,"Failed to accept incomming connections\n");
SYSTEM_ERROR("accept");
edg_wll_gss_release_cred(&cred, NULL);
exit(-1);
} else {
- edg_wll_ll_log(LOG_DEBUG,"Incomming connection on socket '%d'\n",client_fd);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Incomming connection on socket '%d'\n",client_fd);
}
opt = 0;
if (setsockopt(client_fd,IPPROTO_TCP,TCP_CORK,(const void *) &opt,sizeof opt)) {
- edg_wll_ll_log(LOG_WARNING,"Can't reset TCP_CORK\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_WARN,"Can't reset TCP_CORK\n");
}
opt = 1;
if (setsockopt(client_fd,IPPROTO_TCP,TCP_NODELAY,(const void *) &opt,sizeof opt)) {
- edg_wll_ll_log(LOG_WARNING,"Can't set TCP_NODELAY\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_WARN,"Can't set TCP_NODELAY\n");
}
switch (edg_wll_gss_watch_creds(cert_file,&cert_mtime)) {
case 1:
ret = edg_wll_gss_acquire_cred_gsi(cert_file,key_file,&newcred,&gss_stat);
if (ret) {
- edg_wll_ll_log(LOG_WARNING,"Reloading credentials failed, continue with older\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_WARN,"Reloading credentials failed, continue with older\n");
} else {
- edg_wll_ll_log(LOG_DEBUG,"Reloading credentials succeeded\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Reloading credentials succeeded\n");
edg_wll_gss_release_cred(&cred, NULL);
cred = newcred;
}
break;
case -1:
- edg_wll_ll_log(LOG_WARNING,"edg_wll_gss_watch_creds failed\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_WARN,"edg_wll_gss_watch_creds failed\n");
break;
}
if (childpid == 0) {
ret = doit(client_fd,cred,prefix,noIPC,noParse);
if (client_fd) close(client_fd);
- edg_wll_ll_log(LOG_DEBUG,"Exiting.\n",
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Exiting.\n",
CONNECTION_TIMEOUT);
exit(0);
}
if (childpid > 0) {
- edg_wll_ll_log(LOG_DEBUG,"Forked a new child with PID %d\n",childpid);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Forked a new child with PID %d\n",childpid);
if (client_fd) close(client_fd);
}
#else
extern char* socket_path;
-int edg_wll_ll_log_level;
+int glite_common_log_priority_security;
+int glite_common_log_priority_access;
+int glite_common_log_priority_control;
#define tv_sub(a,b) {\
(a).tv_usec -= (b).tv_usec;\
u_int8_t ans_end[4];
edg_wll_GssStatus gss_stat;
- edg_wll_ll_log(LOG_INFO,"Sending answer \"%d\" back to client...",answer);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Sending answer \"%d\" back to client...",answer);
ans_end[0] = ans & 0xff; ans >>= 8;
ans_end[1] = ans & 0xff; ans >>= 8;
ans_end[2] = ans & 0xff; ans >>= 8;
ans_end[3] = ans;
if ((err = edg_wll_gss_write_full(con,ans_end,4,timeout,&count, &gss_stat)) < 0 ) {
- edg_wll_ll_log(LOG_INFO,"error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"error.\n");
return edg_wll_log_proto_server_failure(err,&gss_stat,"Error sending answer");
} else {
- edg_wll_ll_log(LOG_INFO,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"o.k.\n");
return 0;
}
}
/* create socket */
if((confirm_sock=socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
SYSTEM_ERROR("socket");
- edg_wll_ll_log(LOG_ERR,"init_confirmation(): error creating socket\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"init_confirmation(): error creating socket\n");
return(-1);
}
/* bind the socket */
if(bind(confirm_sock, (struct sockaddr *)&saddr, sizeof(saddr.sun_path)) < 0) {
SYSTEM_ERROR("bind");
- edg_wll_ll_log(LOG_ERR,"init_confirmation(): error binding socket\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"init_confirmation(): error binding socket\n");
close(confirm_sock);
unlink(confirm_sock_name);
return(-1);
/* and listen */
if(listen(confirm_sock, 5) < 0) {
SYSTEM_ERROR("listen");
- edg_wll_ll_log(LOG_ERR,"init_confirmation(): error listening on socket\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"init_confirmation(): error listening on socket\n");
close(confirm_sock);
unlink(confirm_sock_name);
return(-1);
/* wait for confirmation at most timeout seconds */
if ((tmp=select(confirm_sock+1, &fds, NULL, NULL, timeout?&to:NULL)) < 0) {
SYSTEM_ERROR("select");
- edg_wll_ll_log(LOG_ERR,"wait_for_confirmation(): error selecting socket\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"wait_for_confirmation(): error selecting socket\n");
ret = -1;
} else {
if (tmp == 0)
ret = 1;
if(nsd < 0) {
SYSTEM_ERROR("accept");
- edg_wll_ll_log(LOG_ERR,"wait_for_confirmation(): error accepting a connection on a socket\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"wait_for_confirmation(): error accepting a connection on a socket\n");
ret = -1;
} else {
if(recv(nsd, code, sizeof(*code), MSG_NOSIGNAL) < 0) {
SYSTEM_ERROR("recv");
- edg_wll_ll_log(LOG_ERR,"wait_for_confirmation(): error receiving a message from a socket\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"wait_for_confirmation(): error receiving a message from a socket\n");
ret = -1;
}
close(nsd);
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock == -1) {
SYSTEM_ERROR("socket");
- edg_wll_ll_log(LOG_ERR,"do_listen(): error creating socket\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"do_listen(): error creating socket\n");
return -1;
}
ret = bind(sock, (struct sockaddr *)&my_addr, sizeof(my_addr));
if (ret == -1) {
SYSTEM_ERROR("bind");
- edg_wll_ll_log(LOG_ERR,"do_listen(): error binding socket\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"do_listen(): error binding socket\n");
return -1;
}
ret = listen(sock, 5);
if (ret == -1) {
SYSTEM_ERROR("listen");
- edg_wll_ll_log(LOG_ERR,"do_listen(): error listening on socket\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"do_listen(): error listening on socket\n");
close(sock);
return -1;
}
/* init */
if (edg_wll_InitContext(&context) != 0) {
- edg_wll_ll_log(LOG_ERR,"edg_wll_InitContex(): error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_InitContex(): error.\n");
answer = ENOMEM;
goto edg_wll_log_proto_server_end;
}
if (edg_wll_ResetError(context) != 0) {
- edg_wll_ll_log(LOG_ERR,"edg_wll_ResetError(): error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_ResetError(): error.\n");
answer = ENOMEM;
goto edg_wll_log_proto_server_end;
}
snprintf(confirm_sock_name, sizeof(confirm_sock_name), "/tmp/dglogd_sock_%ld", lllid);
if ((filedesc = open(confirm_sock_name,O_CREAT)) == -1) {
if (errno == EEXIST) {
- edg_wll_ll_log(LOG_WARNING,"Warning: LLLID %ld already in use.\n",lllid);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_WARN,"Warning: LLLID %ld already in use.\n",lllid);
} else {
SYSTEM_ERROR("open");
}
}
}
if (!unique) {
- edg_wll_ll_log(LOG_ERR,"Cannot determine the unique long local-logger id (LLLID)!\n",lllid);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"Cannot determine the unique long local-logger id (LLLID)!\n",lllid);
return EAGAIN;
}
- edg_wll_ll_log(LOG_INFO,"Long local-logger id (LLLID): %ld\n",lllid);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Long local-logger id (LLLID): %ld\n",lllid);
/* receive socket header */
- edg_wll_ll_log(LOG_INFO,"Reading socket header...");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Reading socket header...");
memset(header, 0, EDG_WLL_LOG_SOCKET_HEADER_LENGTH+1);
if ((err = edg_wll_gss_read_full(con, header, EDG_WLL_LOG_SOCKET_HEADER_LENGTH, timeout, &count, &gss_stat)) < 0) {
if (err == EDG_WLL_GSS_ERROR_EOF) {
- edg_wll_ll_log(LOG_INFO,"no data available.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"no data available.\n");
answer = err;
answer_sent = 1; /* i.e. do not try to send answer back */
} else {
- edg_wll_ll_log(LOG_INFO,"error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"error.\n");
answer = edg_wll_log_proto_server_failure(err,&gss_stat,"Error receiving header");
}
goto edg_wll_log_proto_server_end;
} else {
- edg_wll_ll_log(LOG_INFO,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"o.k.\n");
}
- edg_wll_ll_log(LOG_DEBUG,"Checking socket header...");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Checking socket header...");
header[EDG_WLL_LOG_SOCKET_HEADER_LENGTH] = '\0';
if (strncmp(header,EDG_WLL_LOG_SOCKET_HEADER,EDG_WLL_LOG_SOCKET_HEADER_LENGTH)) {
/* not the proper socket header text */
- edg_wll_ll_log(LOG_DEBUG,"error.\n");
- edg_wll_ll_log(LOG_ERR,"edg_wll_log_proto_server(): invalid socket header\n");
- edg_wll_ll_log(LOG_DEBUG,"edg_wll_log_proto_server(): read header '%s' instead of '%s'\n",
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_log_proto_server(): invalid socket header\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"edg_wll_log_proto_server(): read header '%s' instead of '%s'\n",
header,EDG_WLL_LOG_SOCKET_HEADER);
answer = EINVAL;
goto edg_wll_log_proto_server_end;
} else {
- edg_wll_ll_log(LOG_DEBUG,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"o.k.\n");
}
/* XXX: obsolete
- edg_wll_ll_log(LOG_DEBUG,"Reading message priority...");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Reading message priority...");
count = 0;
if ((err = edg_wll_gss_read_full(con, &priority, sizeof(priority), timeout, &count, &gss_stat)) < 0) {
- edg_wll_ll_log(LOG_DEBUG,"error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"error.\n");
answer = edg_wll_log_proto_server_failure(err,&gss_stat,"Error receiving message priority");
goto edg_wll_log_proto_server_end;
} else {
- edg_wll_ll_log(LOG_DEBUG,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"o.k.\n");
}
*/
- edg_wll_ll_log(LOG_DEBUG,"Reading message size...");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Reading message size...");
count = 0;
if ((err = edg_wll_gss_read_full(con, size_end, 4, timeout, &count,&gss_stat)) < 0) {
- edg_wll_ll_log(LOG_DEBUG,"error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"error.\n");
answer = edg_wll_log_proto_server_failure(err,&gss_stat,"Error receiving message size");
goto edg_wll_log_proto_server_end;
} else {
- edg_wll_ll_log(LOG_DEBUG,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"o.k.\n");
}
size = size_end[3]; size <<=8;
size |= size_end[2]; size <<=8;
size |= size_end[1]; size <<=8;
size |= size_end[0];
- edg_wll_ll_log(LOG_DEBUG,"Checking message size...");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Checking message size...");
if (size <= 0) {
- edg_wll_ll_log(LOG_DEBUG,"error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"error.\n");
/* probably wrong size in the header or nothing to read */
- edg_wll_ll_log(LOG_ERR,"edg_wll_log_proto_server(): invalid size read from socket header\n");
- edg_wll_ll_log(LOG_DEBUG,"Read size '%d'.\n",size);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_log_proto_server(): invalid size read from socket header\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Read size '%d'.\n",size);
answer = EINVAL;
goto edg_wll_log_proto_server_end;
} else {
- edg_wll_ll_log(LOG_DEBUG,"o.k.\n");
- edg_wll_ll_log(LOG_DEBUG,"- Size read from header: %d bytes.\n",size);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"- Size read from header: %d bytes.\n",size);
}
/* format the DG.LLLID string */
if (asprintf(&dglllid,"DG.LLLID=%ld ",lllid) == -1) {
SYSTEM_ERROR("asprintf");
- edg_wll_ll_log(LOG_ERR,"edg_wll_log_proto_server(): nomem for DG.LLLID\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_log_proto_server(): nomem for DG.LLLID\n");
answer = ENOMEM;
goto edg_wll_log_proto_server_end;
}
name_esc = glite_lbu_EscapeULM(name);
if (asprintf(&dguser,"DG.USER=\"%s\" ",name_esc) == -1) {
SYSTEM_ERROR("asprintf");
- edg_wll_ll_log(LOG_ERR,"edg_wll_log_proto_server(): nomem for DG.USER\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_log_proto_server(): nomem for DG.USER\n");
answer = ENOMEM;
goto edg_wll_log_proto_server_end;
}
msg_size = dglllid_size + dguser_size + size + 1;
if ((msg = malloc(msg_size)) == NULL) {
SYSTEM_ERROR("malloc");
- edg_wll_ll_log(LOG_ERR,"edg_wll_log_proto_server(): out of memory for allocating message\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_log_proto_server(): out of memory for allocating message\n");
answer = ENOMEM;
goto edg_wll_log_proto_server_end;
}
strncpy(msg_begin,dguser,dguser_size);
/* receive message */
- edg_wll_ll_log(LOG_INFO,"Reading message from socket...");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Reading message from socket...");
buf = msg_begin + dguser_size;
count = 0;
if ((err = edg_wll_gss_read_full(con, buf, size, timeout, &count, &gss_stat)) < 0) {
- edg_wll_ll_log(LOG_INFO,"error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"error.\n");
answer = edg_wll_log_proto_server_failure(err,&gss_stat,"Error receiving message");
goto edg_wll_log_proto_server_end;
} else {
- edg_wll_ll_log(LOG_INFO,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"o.k.\n");
}
if (buf[count] != '\0') buf[count] = '\0';
/* parse message and get jobId and priority from it */
if (!noparse && strstr(msg, "DG.TYPE=\"command\"") == NULL) {
- edg_wll_ll_log(LOG_INFO,"Parsing message for correctness...");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Parsing message for correctness...");
if (edg_wll_ParseEvent(context,msg_begin,&event) != 0) {
- edg_wll_ll_log(LOG_INFO,"error.\n");
- edg_wll_ll_log(LOG_ERR,"edg_wll_log_proto_server(): edg_wll_ParseEvent error\n");
- edg_wll_ll_log(LOG_ERR,"edg_wll_ParseEvent(): %s\n",context->errDesc);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_log_proto_server(): edg_wll_ParseEvent error\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_ParseEvent(): %s\n",context->errDesc);
answer = edg_wll_Error(context,NULL,NULL);
goto edg_wll_log_proto_server_end;
} else {
- edg_wll_ll_log(LOG_INFO,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"o.k.\n");
}
- edg_wll_ll_log(LOG_DEBUG,"Getting jobId from message...");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Getting jobId from message...");
jobId = edg_wlc_JobIdGetUnique(event->any.jobId);
priority = event->any.priority;
edg_wll_FreeEvent(event);
event->any.priority = priority;
- edg_wll_ll_log(LOG_DEBUG,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"o.k.\n");
} else {
if ((event = edg_wll_InitEvent(EDG_WLL_EVENT_UNDEF)) == NULL) {
- edg_wll_ll_log(LOG_ERR, "edg_wll_InitEvent(): out of memory\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR, "edg_wll_InitEvent(): out of memory\n");
answer = ENOMEM;
goto edg_wll_log_proto_server_end;
}
- edg_wll_ll_log(LOG_DEBUG,"Getting jobId from message...");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Getting jobId from message...");
jobId = edg_wll_GetJobId(msg);
if (!jobId || edg_wlc_JobIdParse(jobId,&j)) {
- edg_wll_ll_log(LOG_DEBUG,"error.\n");
- edg_wll_ll_log(LOG_ERR,"ParseJobId(%s)\n",jobId?jobId:"NULL");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"ParseJobId(%s)\n",jobId?jobId:"NULL");
answer = EINVAL;
goto edg_wll_log_proto_server_end;
} else {
- edg_wll_ll_log(LOG_DEBUG,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"o.k.\n");
}
free(jobId);
jobId = edg_wlc_JobIdGetUnique(j);
/* if not command, save message to file */
if(strstr(msg, "DG.TYPE=\"command\"") == NULL) {
/* compose the name of the log file */
-// edg_wll_ll_log(LOG_DEBUG,"Composing filename from prefix \"%s\" and unique jobId \"%s\"...",prefix,jobId);
+// glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Composing filename from prefix \"%s\" and unique jobId \"%s\"...",prefix,jobId);
count = strlen(prefix);
strncpy(outfilename,prefix,count); count_total=count;
strncpy(outfilename+count_total,".",1); count_total+=1; count=strlen(jobId);
strncpy(outfilename+count_total,jobId,count); count_total+=count;
outfilename[count_total]='\0';
-// edg_wll_ll_log(LOG_DEBUG,"o.k.\n");
+// glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"o.k.\n");
/* fopen and properly handle the filelock */
#ifdef LOGD_NOFILE
- edg_wll_ll_log(LOG_NOTICE,"NOT writing message to \"%s\".\n",outfilename);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_NOTICE,"NOT writing message to \"%s\".\n",outfilename);
filepos = 0;
#else
- edg_wll_ll_log(LOG_INFO,"Writing message to \"%s\"...",outfilename);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Writing message to \"%s\"...",outfilename);
if ( edg_wll_log_event_write(context, outfilename, msg, FCNTL_ATTEMPTS, FCNTL_TIMEOUT, &filepos) ) {
char *errd;
SYSTEM_ERROR("edg_wll_log_event_write");
answer = edg_wll_Error(context, NULL, &errd);
- edg_wll_ll_log(LOG_ERR,"edg_wll_log_event_write error: %s\n",errd);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_log_event_write error: %s\n",errd);
free(errd);
goto edg_wll_log_proto_server_end;
- } else edg_wll_ll_log(LOG_INFO,"o.k.\n");
+ } else glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"o.k.\n");
#endif
} else {
filepos = 0;
}
#ifdef LB_PERF
- edg_wll_ll_log(LOG_INFO,"Calling perftest\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Calling perftest\n");
glite_wll_perftest_consumeEventString(msg);
- edg_wll_ll_log(LOG_INFO,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"o.k.\n");
#endif
/* if not priority send now the answer back to client */
/* send message via IPC (UNIX socket) */
if (!noipc) {
if (event->any.priority & (EDG_WLL_LOGFLAG_SYNC|EDG_WLL_LOGFLAG_SYNC_COMPAT)) {
- edg_wll_ll_log(LOG_DEBUG,"Initializing 2nd UNIX socket (%s) for priority messages confirmation...",confirm_sock_name);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Initializing 2nd UNIX socket (%s) for priority messages confirmation...",confirm_sock_name);
if(init_confirmation() < 0) {
- edg_wll_ll_log(LOG_DEBUG,"error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"error.\n");
answer = errno;
goto edg_wll_log_proto_server_end;
} else {
- edg_wll_ll_log(LOG_DEBUG,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"o.k.\n");
}
}
- edg_wll_ll_log(LOG_DEBUG,
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,
"Sending via IPC (UNIX socket \"%s\")\n\t"
"the message position %ld (%d bytes)",
socket_path, filepos, sizeof(filepos));
char *errd;
SYSTEM_ERROR("edg_wll_log_event_send");
answer = edg_wll_Error(context, NULL, &errd);
- edg_wll_ll_log(LOG_ERR,"edg_wll_log_event_send error: %s\n",errd);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"edg_wll_log_event_send error: %s\n",errd);
free(errd);
goto edg_wll_log_proto_server_end_1;
- } else edg_wll_ll_log(LOG_DEBUG,"o.k.\n");
+ } else glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"o.k.\n");
if (event->any.priority & (EDG_WLL_LOGFLAG_SYNC|EDG_WLL_LOGFLAG_SYNC_COMPAT)) {
- edg_wll_ll_log(LOG_INFO,"Waiting for confirmation...");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Waiting for confirmation...");
if ((count = wait_for_confirmation(timeout, &answer)) < 0) {
- edg_wll_ll_log(LOG_INFO,"error.\n");
- edg_wll_ll_log(LOG_ERR,"wait_for_confirmation(): error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"error.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"wait_for_confirmation(): error.\n");
answer = errno;
} else {
- edg_wll_ll_log(LOG_INFO,"o.k.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"o.k.\n");
if (count == 0) {
- edg_wll_ll_log(LOG_DEBUG,"Waking up, timeout expired.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Waking up, timeout expired.\n");
answer = EAGAIN;
} else {
- edg_wll_ll_log(LOG_DEBUG,"Confirmation received, waking up.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"Confirmation received, waking up.\n");
}
}
}
} else {
- edg_wll_ll_log(LOG_DEBUG,"NOT sending via IPC.\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_DEBUG,"NOT sending via IPC.\n");
}
edg_wll_log_proto_server_end:
if (msg) free(msg);
if (event) free(event);
-// edg_wll_ll_log(LOG_INFO,"Done.\n");
+// glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_INFO,"Done.\n");
return answer;
}
switch(code) {
case EDG_WLL_GSS_ERROR_EOF:
- edg_wll_ll_log(LOG_ERR,"%s: %s, EOF occured\n", func, text);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"%s: %s, EOF occured\n", func, text);
ret = EAGAIN;
break;
case EDG_WLL_GSS_ERROR_TIMEOUT:
- edg_wll_ll_log(LOG_ERR,"%s: %s, timeout expired\n", func, text);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"%s: %s, timeout expired\n", func, text);
ret = EAGAIN;
break;
case EDG_WLL_GSS_ERROR_ERRNO:
SYSTEM_ERROR(func);
- edg_wll_ll_log(LOG_ERR,"%s: %s, system error occured\n", func, text);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"%s: %s, system error occured\n", func, text);
ret = EAGAIN;
break;
case EDG_WLL_GSS_ERROR_GSS:
char *gss_err;
edg_wll_gss_get_error(gss_code, "GSS error occured", &gss_err);
- edg_wll_ll_log(LOG_ERR,"%s: %s, %s\n", func, text, gss_err);
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"%s: %s, %s\n", func, text, gss_err);
free(gss_err);
ret = EAGAIN;
break;
}
default:
- edg_wll_ll_log(LOG_ERR,"%s: %s, unknown error occured\n");
+ glite_common_log(LOG_CATEGORY_NAME,LOG_PRIORITY_ERROR,"%s: %s, unknown error occured\n");
break;
}
return ret;
/*
*----------------------------------------------------------------------
*
- * edg_wll_ll_log_init - initialize the logging level
+ * glite_common_log_init - initialize the logging level
*
*----------------------------------------------------------------------
*/
-void edg_wll_ll_log_init(int level) {
- edg_wll_ll_log_level = level;
+int glite_common_log_init(int a_priority) {
+ int ret = log4c_init();
+
+ if (a_priority != LOG_PRIORITY_NOTSET) {
+ /* override initial priority values */
+ log4c_category_set_priority(log4c_category_get(LOG_CATEGORY_SECURITY),a_priority);
+ log4c_category_set_priority(log4c_category_get(LOG_CATEGORY_ACCESS),a_priority);
+ log4c_category_set_priority(log4c_category_get(LOG_CATEGORY_CONTROL),a_priority);
+ glite_common_log_priority_security = a_priority;
+ glite_common_log_priority_access = a_priority;
+ glite_common_log_priority_control = a_priority;
+ } else {
+ glite_common_log_priority_security = log4c_category_get_priority(log4c_category_get(LOG_CATEGORY_SECURITY));
+ glite_common_log_priority_access = log4c_category_get_priority(log4c_category_get(LOG_CATEGORY_ACCESS));
+ glite_common_log_priority_control = log4c_category_get_priority(log4c_category_get(LOG_CATEGORY_CONTROL));
+ }
+
+ return ret;
+}
+
+/*
+int glite_common_log_setappender(char *catName, char *appName) {
+ log4c_category_set_appender(log4c_category_get(catName)
+ ,log4c_appender_get(appName));
+ return(0);
+}
+*/
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * glite_common_log_fini - finish and explicitly call the log4c cleanup routine
+ *
+ *----------------------------------------------------------------------
+ */
+int glite_common_log_fini() {
+ return(log4c_fini());
}
+
/*
*----------------------------------------------------------------------
*
*
*----------------------------------------------------------------------
*/
-void edg_wll_ll_log(int level, const char *fmt, ...) {
+/*
+void glite_common_log(LOG_CATEGORY_NAME,int level, const char *fmt, ...) {
char *err_text;
va_list fmt_args;
vasprintf(&err_text, fmt, fmt_args);
va_end(fmt_args);
- if(level <= edg_wll_ll_log_level)
+ if(level <= glite_common_log_level)
fprintf(stderr, "[%d] %s", (int) getpid(), err_text);
- if(level <= LOG_ERR) {
+ if(level <= LOG_PRIORITY_ERROR) {
openlog(NULL, LOG_PID | LOG_CONS, LOG_DAEMON);
syslog(level, "%s", err_text);
closelog();
if (err_text) free(err_text);
}
+*/
+
+void glite_common_log_msg(char *catName,int a_priority, char *msg) {
+ const log4c_category_t* a_category = log4c_category_get(catName);
+
+ if (log4c_category_is_priority_enabled(a_category, a_priority)) {
+ log4c_category_log(log4c_category_get(catName), a_priority, msg);
+ }
+}
+
+void glite_common_log(char *catName,int a_priority, const char* a_format,...) {
+ const log4c_category_t* a_category = log4c_category_get(catName);
+
+ if (log4c_category_is_priority_enabled(a_category, a_priority)) {
+ va_list va;
+
+ va_start(va, a_format);
+ log4c_category_vlog(a_category, a_priority, a_format, va);
+ va_end(va);
+ }
+}
+
git://scientific.zcu.cz / jra1mw.git / commitdiff