* use IL communication library

diff --git a/org.glite.lb.server/src/request.c b/org.glite.lb.server/src/request.c
index 0424043..a3288a4 100644 (file)
--- a/org.glite.lb.server/src/request.c
+++ b/org.glite.lb.server/src/request.c
@@ -5,6 +5,7 @@
 #include <string.h>
 
 #include "glite/lb/il_string.h"
+#include "glite/lb/il_msg.h"
 #include "glite/lb/context-int.h"
 
 #include "store.h"
@@ -16,28 +17,21 @@
 #endif
     
 int 
-handle_request(edg_wll_Context ctx,char *buf, int len UNUSED_VAR)
+handle_request(edg_wll_Context ctx,char *buf)
 {
-  char *p = buf;
-  char *event, *ucs;
+  char *event;
   int ret;
 
   edg_wll_ResetError(ctx);
 
-  p = get_string(p, &ucs);
-  if(p == NULL) return edg_wll_SetError(ctx,EDG_WLL_IL_PROTO,"reading UCS");
-
-  p = get_string(p, &event);
-  if(p == NULL) {
+  ret = decode_il_msg(&event, buf);
+  if(ret < 0) {
     edg_wll_SetError(ctx,EDG_WLL_IL_PROTO,"reading event string");
-    if(ucs) free(ucs);
     return EDG_WLL_IL_PROTO;
   }
 
-  ret = db_store(ctx,ucs, event);
+  ret = db_store(ctx, "NOT USED", event);
 
-  if(ucs)
-    free(ucs);
   if(event)
     free(event);
 
@@ -46,10 +40,9 @@ handle_request(edg_wll_Context ctx,char *buf, int len UNUSED_VAR)
 
 
 int 
-create_reply(const edg_wll_Context ctx,char *buf, int max_len)
+create_reply(const edg_wll_Context ctx, char **buf)
 {
   int len, err_code, err_code_min;
-  char *p;
   char *err_msg;
 
   err_code_min = 0;
@@ -77,19 +70,8 @@ create_reply(const edg_wll_Context ctx,char *buf, int max_len)
 
   if (!err_msg) err_msg=strdup("OK");
   
-  len = 17 + len_int(err_code) + len_int(err_code_min) + len_string(err_msg);
-  if(len > max_len) {
-    free(err_msg);
-    return(0);
-  }
-
-  snprintf(buf, max_len, "%16d\n", len - 17);
-  p = buf + 17;
-  p = put_int(p, err_code);
-  p = put_int(p, err_code_min);
-  p = put_string(p, err_msg);
+  len = encode_il_reply(buf, err_code, err_code_min, err_msg);
   free(err_msg);
-  
   return(len);
 }
 

diff --git a/org.glite.lb.server/src/store.h b/org.glite.lb.server/src/store.h
index ff62047..3466d05 100644 (file)
--- a/org.glite.lb.server/src/store.h
+++ b/org.glite.lb.server/src/store.h
@@ -34,8 +34,8 @@ edg_wll_ErrorCode edg_wll_StepIntState(
 );
 
 int db_store(edg_wll_Context,char *,char *);
-int handle_request(edg_wll_Context,char *, int);
-int create_reply(const edg_wll_Context,char *,int);
+int handle_request(edg_wll_Context,char *);
+int create_reply(const edg_wll_Context,char **);
 
 int edg_wll_delete_event(edg_wll_Context,const char *, int);
 

diff --git a/org.glite.lb.server/src/stored_master.c b/org.glite.lb.server/src/stored_master.c
index bfc2f8d..7c045a0 100644 (file)
--- a/org.glite.lb.server/src/stored_master.c
+++ b/org.glite.lb.server/src/stored_master.c
@@ -8,85 +8,108 @@
 #include <errno.h>
 #include <assert.h>
 
-#include "glite/lb/il_string.h"
+#include "glite/lb/il_msg.h"
 #include "glite/lb/lb_gss.h"
 #include "glite/lb/lb_plain_io.h"
 #include "glite/lb/context-int.h"
 
 #include "store.h"
 
-int edg_wll_StoreProto(edg_wll_Context ctx)
+static edg_wll_Context tmp_ctx;
+
+static
+int
+gss_reader(char *buffer, int max_len)
 {
-       char    fbuf[256],*buf;
-       int     len,ret;
-       size_t  total;
-       edg_wll_GssStatus       gss_code;
+  int ret, len;
+  edg_wll_GssStatus gss_code;
 
-       edg_wll_ResetError(ctx);
-       if ((ret=edg_wll_gss_read_full(&ctx->connPool[ctx->connToUse].gss,fbuf,17,&ctx->p_tmp_timeout,&total,&gss_code)) < 0) switch (ret) {
-               case EDG_WLL_GSS_ERROR_TIMEOUT: return edg_wll_SetError(ctx,ETIMEDOUT,"read message header");
-               case EDG_WLL_GSS_ERROR_EOF: return edg_wll_SetError(ctx,ENOTCONN,NULL);
-               default: return edg_wll_SetError(ctx,EDG_WLL_ERROR_GSS,"read message header");
-       }
+  ret = edg_wll_gss_read_full(&tmp_ctx->connPool[tmp_ctx->connToUse].gss,
+                             buffer, max_len,
+                             &tmp_ctx->p_tmp_timeout,
+                             &len, &gss_code);
+  if(ret < 0) switch(ret) {
 
-       if ((len = atoi(fbuf)) <= 0) return edg_wll_SetError(ctx,EINVAL,"message length");
+  case EDG_WLL_GSS_ERROR_TIMEOUT: 
+    ret = edg_wll_SetError(tmp_ctx, ETIMEDOUT, "read message");
+    break;
 
-       buf = malloc(len+1);
+  case EDG_WLL_GSS_ERROR_EOF:
+    ret = edg_wll_SetError(tmp_ctx, ENOTCONN, NULL);
+    break;
+
+  default:
+    ret = edg_wll_SetError(tmp_ctx, EDG_WLL_ERROR_GSS, "read message");
+    break;
+  }
+
+  return(ret);
+}
 
-       if ((ret=edg_wll_gss_read_full(&ctx->connPool[ctx->connToUse].gss,buf,len,&ctx->p_tmp_timeout,&total,&gss_code)) < 0) {
-               free(buf);
-               return edg_wll_SetError(ctx,
-                       ret == EDG_WLL_GSS_ERROR_TIMEOUT ?
-                               ETIMEDOUT : EDG_WLL_ERROR_GSS,
-                       "read message");
-       }
 
+int edg_wll_StoreProto(edg_wll_Context ctx)
+{
+       char    *buf;
+       int     len,ret;
+       size_t  total;
+       edg_wll_GssStatus       gss_code;
 
-       buf[len] = 0;
+       edg_wll_ResetError(ctx);
+       tmp_ctx = ctx;
+       ret = read_il_data(&buf, gss_reader);
+       if(ret < 0) 
+         return(ret);
 
-       handle_request(ctx,buf,len);
+       handle_request(ctx,buf);
        free(buf);
 
-       if ((len = create_reply(ctx,fbuf,sizeof fbuf))) {
-               if ((ret = edg_wll_gss_write_full(&ctx->connPool[ctx->connToUse].gss,fbuf,len,&ctx->p_tmp_timeout,&total,&gss_code)) < 0)
+       if ((len = create_reply(ctx,&buf)) > 0) {
+               if ((ret = edg_wll_gss_write_full(&ctx->connPool[ctx->connToUse].gss,buf,len,&ctx->p_tmp_timeout,&total,&gss_code)) < 0)
                        edg_wll_SetError(ctx,
                                ret == EDG_WLL_GSS_ERROR_TIMEOUT ? 
                                        ETIMEDOUT : EDG_WLL_ERROR_GSS,
                                "write reply");
+               free(buf);
        }
        else edg_wll_SetError(ctx,E2BIG,"create_reply()");
 
        return edg_wll_Error(ctx,NULL,NULL);
 }
 
-int edg_wll_StoreProtoProxy(edg_wll_Context ctx)
+
+static
+int
+gss_plain_reader(char *buffer, int max_len)
 {
-       char    fbuf[256], *buf;
-       int             len, ret;
+  int ret;
 
+  ret = edg_wll_plain_read_full(&tmp_ctx->connProxy->conn, buffer, max_len,
+                               &tmp_ctx->p_tmp_timeout);
+  if(ret < 0) return(edg_wll_SetError(tmp_ctx, errno, "StoreProtoProxy() - reading data"));
 
-       edg_wll_ResetError(ctx);
-       ret = edg_wll_plain_read_full(&ctx->connProxy->conn, fbuf, 17, &ctx->p_tmp_timeout);
-       if ( ret < 0 ) return edg_wll_SetError(ctx, errno, "StoreProtoProxy() - reading data");
+  return(ret);
+}
 
-       len = atoi(fbuf);
-       if ( len <= 0 ) return edg_wll_SetError(ctx, EINVAL, "message length");
 
-       buf = malloc(len+1);
-       if ( !buf ) return edg_wll_SetError(ctx, errno, "StoreProtoProxy()");
+int edg_wll_StoreProtoProxy(edg_wll_Context ctx)
+{
+       char    *buf;
+       int             len, ret;
 
-       if ( edg_wll_plain_read_full(&ctx->connProxy->conn, buf, len, &ctx->p_tmp_timeout) < 0) {
-               free(buf);
-               return edg_wll_SetError(ctx, errno, "StoreProtoProxy() - reading data");
-       }
 
-       buf[len] = 0;
-       handle_request(ctx, buf, len);
+       edg_wll_ResetError(ctx);
+       tmp_ctx = ctx;
+       ret = read_il_data(&buf, gss_plain_reader);
+       if(ret < 0)
+         return(ret);
+
+       handle_request(ctx, buf);
        free(buf);
 
-       if ( (len = create_reply(ctx, fbuf, sizeof fbuf)) ) {
-               if ( edg_wll_plain_write_full(&ctx->connProxy->conn, fbuf, len, &ctx->p_tmp_timeout) < 0 )
+       if ( (len = create_reply(ctx, &buf)) > 0 ) {
+               if ( edg_wll_plain_write_full(&ctx->connProxy->conn, buf, len, &ctx->p_tmp_timeout) < 0 )
                        return edg_wll_SetError(ctx, errno, "StoreProtoProxy() - sending reply");
+               free(buf);
        }
        else edg_wll_SetError(ctx, E2BIG, "create_reply()");