X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=tid%2Ftids.c;h=ada82a69df7764b320a6632275194d2698b46cd4;hb=45c8d1e8259cae6eaaee3b4a66660a9aa92b1d5b;hp=ed525d8290fa3c255408a5fd74cfede3f347377e;hpb=031c062fe34166b437ae271372d0c2bc8a21b208;p=trust_router.git

diff --git a/tid/tids.c b/tid/tids.c
index ed525d8..ada82a6 100644
--- a/tid/tids.c
+++ b/tid/tids.c
@@ -53,7 +53,7 @@ static TID_RESP *tids_create_response (TIDS_INSTANCE *tids, TID_REQ *req)
   TID_RESP *resp;
 
   if ((NULL == (resp = talloc_zero(req, TID_RESP)))) {
-    fprintf(stderr, "tids_create_response: Error allocating response structure.\n");
+    tr_crit("tids_create_response: Error allocating response structure.");
     return NULL;
   }
   
@@ -61,12 +61,12 @@ static TID_RESP *tids_create_response (TIDS_INSTANCE *tids, TID_REQ *req)
   if ((NULL == (resp->rp_realm = tr_dup_name(req->rp_realm))) ||
       (NULL == (resp->realm = tr_dup_name(req->realm))) ||
       (NULL == (resp->comm = tr_dup_name(req->comm)))) {
-    fprintf(stderr, "tids_create_response: Error allocating fields in response.\n");
+    tr_crit("tids_create_response: Error allocating fields in response.");
     return NULL;
   }
   if (req->orig_coi) {
     if (NULL == (resp->orig_coi = tr_dup_name(req->orig_coi))) {
-      fprintf(stderr, "tids_create_response: Error allocating fields in response.\n");
+      tr_crit("tids_create_response: Error allocating fields in response.");
       return NULL;
     }
   }
@@ -102,24 +102,24 @@ static int tids_listen (TIDS_INSTANCE *tids, int port)
     } addr;
 
     struct sockaddr_in *saddr = (struct sockaddr_in *) &addr.in4;
-    
+
     saddr->sin_port = htons (port);
     saddr->sin_family = AF_INET;
     saddr->sin_addr.s_addr = INADDR_ANY;
 
     if (0 > (conn = socket (AF_INET, SOCK_STREAM, 0)))
       return conn;
-        
+
     setsockopt(conn, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
 
     if (0 > (rc = bind (conn, (struct sockaddr *) saddr, sizeof(struct sockaddr_in))))
       return rc;
-        
+
     if (0 > (rc = listen(conn, 512)))
       return rc;
-    
-    fprintf (stdout, "tids_listen: TID Server listening on port %d\n", port);
-    return conn; 
+
+    tr_debug("tids_listen: TID Server listening on port %d", port);
+    return conn;
 }
 
 static int tids_auth_cb(gss_name_t clientName, gss_buffer_t displayName,
@@ -145,20 +145,20 @@ static int tids_auth_connection (struct tids_instance *inst,
   nameBuffer.value = name;
   
   if (rc = gsscon_passive_authenticate(conn, nameBuffer, gssctx, tids_auth_cb, inst)) {
-    fprintf(stderr, "tids_auth_connection: Error from gsscon_passive_authenticate(), rc = %d.\n", rc);
+    tr_debug("tids_auth_connection: Error from gsscon_passive_authenticate(), rc = %d.", rc);
     return -1;
   }
 
   if (rc = gsscon_authorize(*gssctx, &auth, &autherr)) {
-    fprintf(stderr, "tids_auth_connection: Error from gsscon_authorize, rc = %d, autherr = %d.\n", 
+    tr_debug("tids_auth_connection: Error from gsscon_authorize, rc = %d, autherr = %d.", 
 	    rc, autherr);
     return -1;
   }
 
   if (auth)
-    fprintf(stdout, "tids_auth_connection: Connection authenticated, conn = %d.\n", conn);
+    tr_debug("tids_auth_connection: Connection authenticated, conn = %d.", conn);
   else
-    fprintf(stderr, "tids_auth_connection: Authentication failed, conn %d.\n", conn);
+    tr_debug("tids_auth_connection: Authentication failed, conn %d.", conn);
 
   return !auth;
 }
@@ -175,18 +175,18 @@ static int tids_read_request (TIDS_INSTANCE *tids, int conn, gss_ctx_id_t *gssct
     return -1;
   }
 
-  fprintf(stdout, "tids_read_request():Request Received, %u bytes.\n", (unsigned) buflen);
+  tr_debug("tids_read_request():Request Received, %u bytes.", (unsigned) buflen);
 
   /* Parse request */
   if (NULL == ((*mreq) = tr_msg_decode(buf, buflen))) {
-    fprintf(stderr, "tids_read_request():Error decoding request.\n");
+    tr_debug("tids_read_request():Error decoding request.");
     free (buf);
     return -1;
   }
 
   /* If this isn't a TID Request, just drop it. */
   if (TID_REQUEST != (*mreq)->msg_type) {
-    fprintf(stderr, "tids_read_request(): Not a TID Request, dropped.\n");
+    tr_debug("tids_read_request(): Not a TID Request, dropped.");
     return -1;
   }
 
@@ -203,7 +203,7 @@ static int tids_handle_request (TIDS_INSTANCE *tids, TR_MSG *mreq, TID_RESP *res
       (!tr_msg_get_req(mreq)->rp_realm) ||
       (!tr_msg_get_req(mreq)->realm) ||
       (!tr_msg_get_req(mreq)->comm)) {
-    fprintf(stderr, "tids_handle_request():Not a valid TID Request.\n");
+    tr_notice("tids_handle_request(): Not a valid TID Request.");
     resp->result = TID_ERROR;
     resp->err_msg = tr_new_name("Bad request format");
     return -1;
@@ -235,7 +235,7 @@ int tids_send_err_response (TIDS_INSTANCE *tids, TID_REQ *req, const char *err_m
     return 0;
 
   if (NULL == (resp = tids_create_response(tids, req))) {
-    fprintf(stderr, "tids_send_err_response: Can't create response.\n");
+    tr_crit("tids_send_err_response: Can't create response.");
     return -1;
   }
 
@@ -256,7 +256,7 @@ int tids_send_response (TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp)
   char *resp_buf;
 
   if ((!tids) || (!req) || (!resp))
-    fprintf (stderr, "tids_send_response: Invalid parameters.\n");
+    tr_debug("tids_send_response: Invalid parameters.");
 
   /* Never send a second response if we already sent one. */
   if (req->resp_sent)
@@ -264,16 +264,17 @@ int tids_send_response (TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp)
 
   mresp.msg_type = TID_RESPONSE;
   tr_msg_set_resp(&mresp, resp);
-  
+
   if (NULL == (resp_buf = tr_msg_encode(&mresp))) {
+
     fprintf(stderr, "tids_send_response: Error encoding json response.\n");
     tr_audit_req(req);
 
     return -1;
   }
 
-  fprintf(stderr, "tids_send_response: Encoded response:\n%s\n", resp_buf);
-  
+  tr_debug("tids_send_response: Encoded response: %s", resp_buf);
+
   /* If external logging is enabled, fire off a message */
   /* TODO Can be moved to end once segfault in gsscon_write_encrypted_token fixed */
   tr_audit_resp(resp);
@@ -281,7 +282,7 @@ int tids_send_response (TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp)
   /* Send the response over the connection */
   if (err = gsscon_write_encrypted_token (req->conn, req->gssctx, resp_buf, 
 					  strlen(resp_buf) + 1)) {
-    fprintf(stderr, "tids_send_response: Error sending response over connection.\n");
+    tr_notice("tids_send_response: Error sending response over connection.");
 
     tr_audit_req(req);
 
@@ -304,17 +305,17 @@ static void tids_handle_connection (TIDS_INSTANCE *tids, int conn)
   gss_ctx_id_t gssctx = GSS_C_NO_CONTEXT;
 
   if (tids_auth_connection(tids, conn, &gssctx)) {
-    fprintf(stderr, "tids_handle_connection: Error authorizing TID Server connection.\n");
+    tr_notice("tids_handle_connection: Error authorizing TID Server connection.");
     close(conn);
     return;
   }
 
-  fprintf(stdout, "tids_handle_connection: Connection authorized!\n");
+  tr_debug("tids_handle_connection: Connection authorized!");
 
   while (1) {	/* continue until an error breaks us out */
 
     if (0 > (rc = tids_read_request(tids, conn, &gssctx, &mreq))) {
-      fprintf(stderr, "tids_handle_connection: Error from tids_read_request(), rc = %d.\n", rc);
+      tr_debug("tids_handle_connection: Error from tids_read_request(), rc = %d.", rc);
       return;
     } else if (0 == rc) {
       continue;
@@ -326,22 +327,22 @@ static void tids_handle_connection (TIDS_INSTANCE *tids, int conn)
 
     /* Allocate a response structure and populate common fields */
     if (NULL == (resp = tids_create_response (tids, tr_msg_get_req(mreq)))) {
-      fprintf(stderr, "tids_handle_connection: Error creating response structure.\n");
+      tr_crit("tids_handle_connection: Error creating response structure.");
       /* try to send an error */
-      tids_send_err_response(tids, tr_msg_get_req(mreq), "Error creating response.\n");
+      tids_send_err_response(tids, tr_msg_get_req(mreq), "Error creating response.");
       return;
     }
 
     if (0 > (rc = tids_handle_request(tids, mreq, resp))) {
-      fprintf(stderr, "tids_handle_connection: Error from tids_handle_request(), rc = %d.\n", rc);
+      tr_debug("tids_handle_connection: Error from tids_handle_request(), rc = %d.", rc);
       /* Fall through, to send the response, either way */
     }
 
     if (0 > (rc = tids_send_response(tids, tr_msg_get_req(mreq), resp))) {
-      fprintf(stderr, "tids_handle_connection: Error from tids_send_response(), rc = %d.\n", rc);
+      tr_debug("tids_handle_connection: Error from tids_send_response(), rc = %d.", rc);
       /* if we didn't already send a response, try to send a generic error. */
       if (!tr_msg_get_req(mreq)->resp_sent)
-	tids_send_err_response(tids, tr_msg_get_req(mreq), "Error sending response.\n");
+	tids_send_err_response(tids, tr_msg_get_req(mreq), "Error sending response.");
       /* Fall through to free the response, either way. */
     }
     
@@ -410,11 +411,9 @@ int tids_start (TIDS_INSTANCE *tids,
 
 void tids_destroy (TIDS_INSTANCE *tids)
 {
-  /* close syslog connection if syslog is enabled */
+  /* clean up logfiles */
   tr_log_close();
 
   if (tids)
     free(tids);
 }
-
-