X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=lib%2Flibnfs-zdr.c;h=b6b3ed984bfc35edcf2ed3e0be693861cf88500b;hb=10a1a78115069098419d32a042d99a56f62fb642;hp=8a60491cfc6f3a9309fcbc587676aaba8731933a;hpb=442b829a054a0e02f26bc050346f3e4df18c579d;p=deb_libnfs.git

diff --git a/lib/libnfs-zdr.c b/lib/libnfs-zdr.c
index 8a60491..b6b3ed9 100644
--- a/lib/libnfs-zdr.c
+++ b/lib/libnfs-zdr.c
@@ -20,9 +20,26 @@
  * i.e. zdrmem_create() buffers.
  * It aims to be compatible with normal rpcgen generated functions.
  */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32_compat.h"
+#endif
+
+#ifdef AROS
+#include "aros_compat.h"
+#endif
+
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
 
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
+#include <unistd.h>
 #include "libnfs-zdr.h"
 
 struct opaque_auth _null_auth;
@@ -116,7 +133,7 @@ bool_t libnfs_zdr_u_quad_t(ZDR *zdrs, uint64_t *u)
 		*u = ntohl(*(uint32_t *)&zdrs->buf[zdrs->pos]);
 		zdrs->pos += 4;
 		*u <<= 32;
-		*u |= ntohl(*(uint32_t *)&zdrs->buf[zdrs->pos]);
+		*u |= (uint32_t)ntohl(*(uint32_t *)&zdrs->buf[zdrs->pos]);
 		zdrs->pos += 4;
 		return TRUE;
 		break;
@@ -211,6 +228,9 @@ bool_t libnfs_zdr_opaque(ZDR *zdrs, char *objp, uint32_t size)
 	case ZDR_ENCODE:
 		memcpy(&zdrs->buf[zdrs->pos], objp, size);
 		zdrs->pos += size;
+		if (zdrs->pos & 3) {
+			memset(&zdrs->buf[zdrs->pos], 0x00, 4 - (zdrs->pos & 3));
+		}
 		zdrs->pos = (zdrs->pos + 3) & ~3;
 		return TRUE;
 	case ZDR_DECODE:
@@ -275,7 +295,7 @@ bool_t libnfs_zdr_array(ZDR *zdrs, char **arrp, uint32_t *size, uint32_t maxsize
 	}
 
 	for (i = 0; i < *size; i++) {
-		if (proc(zdrs, *arrp + i * elsize)) {
+		if (!proc(zdrs, *arrp + i * elsize)) {
 			return FALSE;
 		}
 	}
@@ -299,29 +319,41 @@ static bool_t libnfs_opaque_auth(ZDR *zdrs, struct opaque_auth *auth)
 	return TRUE;
 }
 
-static bool_t libnfs_rpc_call_body(ZDR *zdrs, struct call_body *cmb)
+static bool_t libnfs_rpc_call_body(struct rpc_context *rpc, ZDR *zdrs, struct call_body *cmb)
 {
-	if (!libnfs_zdr_u_int(zdrs, &cmb->cb_rpcvers)) {
+	if (!libnfs_zdr_u_int(zdrs, &cmb->rpcvers)) {
+		rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode "
+			"RPCVERS");
 		return FALSE;
 	}
 
-	if (!libnfs_zdr_u_int(zdrs, &cmb->cb_prog)) {
+	if (!libnfs_zdr_u_int(zdrs, &cmb->prog)) {
+		rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode "
+			"PROG");
 		return FALSE;
 	}
 
-	if (!libnfs_zdr_u_int(zdrs, &cmb->cb_vers)) {
+	if (!libnfs_zdr_u_int(zdrs, &cmb->vers)) {
+		rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode "
+			"VERS");
 		return FALSE;
 	}
 
-	if (!libnfs_zdr_u_int(zdrs, &cmb->cb_proc)) {
+	if (!libnfs_zdr_u_int(zdrs, &cmb->proc)) {
+		rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode "
+			"PROC");
 		return FALSE;
 	}
 
-	if (!libnfs_opaque_auth(zdrs, &cmb->cb_cred)) {
+	if (!libnfs_opaque_auth(zdrs, &cmb->cred)) {
+		rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode "
+			"CRED");
 		return FALSE;
 	}
 
-	if (!libnfs_opaque_auth(zdrs, &cmb->cb_verf)) {
+	if (!libnfs_opaque_auth(zdrs, &cmb->verf)) {
+		rpc_set_error(rpc, "libnfs_rpc_call_body failed to encode "
+			"VERF");
 		return FALSE;
 	}
 
@@ -330,25 +362,25 @@ static bool_t libnfs_rpc_call_body(ZDR *zdrs, struct call_body *cmb)
 
 static bool_t libnfs_accepted_reply(ZDR *zdrs, struct accepted_reply *ar)
 {
-	if (!libnfs_opaque_auth(zdrs, &ar->ar_verf)) {
+	if (!libnfs_opaque_auth(zdrs, &ar->verf)) {
 		return FALSE;
 	}
 
-	if (!libnfs_zdr_u_int(zdrs, &ar->ar_stat)) {
+	if (!libnfs_zdr_u_int(zdrs, &ar->stat)) {
 		return FALSE;
 	}
 
-	switch (ar->ar_stat) {
+	switch (ar->stat) {
 	case SUCCESS:
-		if (!ar->ar_results.proc(zdrs, ar->ar_results.where)) {
+		if (!ar->reply_data.results.proc(zdrs, ar->reply_data.results.where)) {
 			return FALSE;
 		}
 		return TRUE;
 	case PROG_MISMATCH:
-		if (!libnfs_zdr_u_int(zdrs, &ar->ar_vers.low)) {
+		if (!libnfs_zdr_u_int(zdrs, &ar->reply_data.mismatch_info.low)) {
 			return FALSE;
 		}
-		if (!libnfs_zdr_u_int(zdrs, &ar->ar_vers.high)) {
+		if (!libnfs_zdr_u_int(zdrs, &ar->reply_data.mismatch_info.high)) {
 			return FALSE;
 		}
 		return TRUE;
@@ -359,64 +391,107 @@ static bool_t libnfs_accepted_reply(ZDR *zdrs, struct accepted_reply *ar)
 	return FALSE;
 }
 
-static bool_t libnfs_rejected_reply(ZDR *zdrs, struct rejected_reply *RP_dr)
+static bool_t libnfs_rejected_reply(ZDR *zdrs, struct rejected_reply *rr)
 {
-printf("rejected reply\n");
-exit(10);
+	if (!libnfs_zdr_u_int(zdrs, &rr->stat)) {
+		return FALSE;
+	}
+
+	switch (rr->stat) {
+	case RPC_MISMATCH:
+		if (!libnfs_zdr_u_int(zdrs, &rr->reject_data.mismatch_info.low)) {
+			return FALSE;
+		}
+		if (!libnfs_zdr_u_int(zdrs, &rr->reject_data.mismatch_info.high)) {
+			return FALSE;
+		}
+		return TRUE;
+	case AUTH_ERROR:
+		if (!libnfs_zdr_u_int(zdrs, &rr->reject_data.stat)) {
+			return FALSE;
+		}
+		return TRUE;
+	default:
+		return TRUE;
+	}
+
+	return FALSE;
 }
 
-static bool_t libnfs_rpc_reply_body(ZDR *zdrs, struct reply_body *rmb)
+static bool_t libnfs_rpc_reply_body(struct rpc_context *rpc, ZDR *zdrs, struct reply_body *rmb)
 {
-	if (!libnfs_zdr_u_int(zdrs, &rmb->rp_stat)) {
+	if (!libnfs_zdr_u_int(zdrs, &rmb->stat)) {
+		rpc_set_error(rpc, "libnfs_rpc_reply_body failed to decode "
+			"STAT");
 		return FALSE;
 	}
 
-	switch (rmb->rp_stat) {
+	switch (rmb->stat) {
 	case MSG_ACCEPTED:
-		if (!libnfs_accepted_reply(zdrs, &rmb->rp_acpt)) {
+		if (!libnfs_accepted_reply(zdrs, &rmb->reply.areply)) {
+			rpc_set_error(rpc, "libnfs_rpc_reply_body failed to "
+				"decode ACCEPTED");
 			return FALSE;
 		}
 		return TRUE;
 	case MSG_DENIED:
-		if (!libnfs_rejected_reply(zdrs, &rmb->rp_rjct)) {
+		if (!libnfs_rejected_reply(zdrs, &rmb->reply.rreply)) {
+			rpc_set_error(rpc, "libnfs_rpc_reply_body failed to "
+				"decode DENIED");
 			return FALSE;
 		}
 		return TRUE;
 	}
 
+	rpc_set_error(rpc, "libnfs_rpc_reply_body failed to "
+		"decode. Neither ACCEPTED nor DENIED");
 	return FALSE;
 }
 
-static bool_t libnfs_rpc_msg(ZDR *zdrs, struct rpc_msg *msg)
+static bool_t libnfs_rpc_msg(struct rpc_context *rpc, ZDR *zdrs, struct rpc_msg *msg)
 {
-	if (!libnfs_zdr_u_int(zdrs, &msg->rm_xid)) {
+	int ret;
+
+	if (!libnfs_zdr_u_int(zdrs, &msg->xid)) {
+		rpc_set_error(rpc, "libnfs_rpc_msg failed to decode XID");
 		return FALSE;
 	}
 
-	if (!libnfs_zdr_u_int(zdrs, &msg->rm_direction)) {
+	if (!libnfs_zdr_u_int(zdrs, &msg->direction)) {
+		rpc_set_error(rpc, "libnfs_rpc_msg failed to decode DIRECTION");
 		return FALSE;
 	}
 
-	switch (msg->rm_direction) {
+	switch (msg->direction) {
 	case CALL:
-		return libnfs_rpc_call_body(zdrs, &msg->ru.RM_cmb);
-		break;
+		ret = libnfs_rpc_call_body(rpc, zdrs, &msg->body.cbody);
+		if (!ret) { 
+			rpc_set_error(rpc, "libnfs_rpc_msg failed to encode "
+				"CALL, ret=%d: %s", ret, rpc_get_error(rpc));
+		}
+		return ret;
 	case REPLY:
-		return libnfs_rpc_reply_body(zdrs, &msg->ru.RM_rmb);
-		break;
+		ret = libnfs_rpc_reply_body(rpc, zdrs, &msg->body.rbody);
+		if (!ret) { 
+			rpc_set_error(rpc, "libnfs_rpc_msg failed to decode "
+				"REPLY, ret=%d: %s", ret, rpc_get_error(rpc));
+		}
+		return ret;
 	default:
+		rpc_set_error(rpc, "libnfs_rpc_msg failed to decode. "
+			"Neither CALL not REPLY");
 		return FALSE;
 	}
 }
 
-bool_t libnfs_zdr_callmsg(ZDR *zdrs, struct rpc_msg *msg)
+bool_t libnfs_zdr_callmsg(struct rpc_context *rpc, ZDR *zdrs, struct rpc_msg *msg)
 {
-	return libnfs_rpc_msg(zdrs, msg);
+	return libnfs_rpc_msg(rpc, zdrs, msg);
 }
 
-bool_t libnfs_zdr_replymsg(ZDR *zdrs, struct rpc_msg *msg)
+bool_t libnfs_zdr_replymsg(struct rpc_context *rpc, ZDR *zdrs, struct rpc_msg *msg)
 {
-	return libnfs_rpc_msg(zdrs, msg);
+	return libnfs_rpc_msg(rpc, zdrs, msg);
 }
 
 struct AUTH *authnone_create(void)
@@ -447,10 +522,12 @@ struct AUTH *libnfs_authunix_create(char *host, uint32_t uid, uint32_t gid, uint
 
 	size = 4 + 4 + ((strlen(host) + 3) & ~3) + 4 + 4 + 4 + len * 4;
 	auth = malloc(sizeof(struct AUTH));
+	memset(auth, 0x00, sizeof(struct AUTH));
 	auth->ah_cred.oa_flavor = AUTH_UNIX;
 	auth->ah_cred.oa_length = size;
 	auth->ah_cred.oa_base = malloc(size);
 
+	memset(auth->ah_cred.oa_base, 0x00, size);
 	buf = (uint32_t *)auth->ah_cred.oa_base;
 	idx = 0;
 	buf[idx++] = htonl(time(NULL));
@@ -476,7 +553,11 @@ struct AUTH *libnfs_authunix_create(char *host, uint32_t uid, uint32_t gid, uint
 
 struct AUTH *libnfs_authunix_create_default(void)
 {
-	return libnfs_authunix_create("libnfs", getuid(), -1, 0, NULL);
+#ifdef WIN32
+	return libnfs_authunix_create("libnfs", 65534, 65534, 0, NULL);
+#else
+	return libnfs_authunix_create("libnfs", getuid(), getgid(), 0, NULL);
+#endif
 }
 
 void libnfs_auth_destroy(struct AUTH *auth)