NSS: Add sss_readrep_copy_string

There were many places in the client code where we were
duplicating a loop to copy data in from the response buffer. This
patch turns those loops into a function for easier maintenance and
easier-to-read *readrep() routines.

1 files changed, 40 insertions, 65 deletions

diff --git a/src/sss_client/nss_netgroup.c b/src/sss_client/nss_netgroup.c
index f63b11359..f72d547e8 100644
--- a/src/sss_client/nss_netgroup.c
+++ b/src/sss_client/nss_netgroup.c
@@ -62,9 +62,10 @@ struct sss_nss_netgr_rep {
 static int sss_nss_getnetgr_readrep(struct sss_nss_netgr_rep *pr,
                                     uint8_t *buf, size_t *len)
 {
+    errno_t ret;
     char *sbuf;
-    size_t i, slen;
-    ssize_t dlen;
+    char *temp;
+    size_t i, slen, dlen, size;
     uint32_t type;
 
     if (*len < 6) {
@@ -84,92 +85,66 @@ static int sss_nss_getnetgr_readrep(struct sss_nss_netgr_rep *pr,
             pr->result->type = triple_val;
 
             /* Host value */
-            pr->result->val.triple.host = &(pr->buffer[i]);
-            while (slen > i && dlen > 0) {
-                pr->buffer[i] = sbuf[i];
-                if (pr->buffer[i] == '\0') break;
-                i++;
-                dlen--;
-            }
-            if (slen <= i) { /* premature end of buf */
-                return EBADMSG;
-            }
-            if (dlen <= 0) { /* not enough memory */
-                return ERANGE; /* not ENOMEM, ERANGE is what glibc looks for */
-            }
-            i++;
-            dlen--;
+            temp = &(pr->buffer[i]);
+            ret = sss_readrep_copy_string(sbuf, &i,
+                                          &slen, &dlen,
+                                          &temp,
+                                          &size);
+            if (ret != EOK) return ret;
 
             /* libc expects NULL instead of empty string */
-            if (strlen(pr->result->val.triple.host) == 0) {
+            if (size == 0) {
                 pr->result->val.triple.host = NULL;
+            } else {
+                pr->result->val.triple.host = temp;
             }
 
             /* User value */
-            pr->result->val.triple.user = &(pr->buffer[i]);
-            while (slen > i && dlen > 0) {
-                pr->buffer[i] = sbuf[i];
-                if (pr->buffer[i] == '\0') break;
-                i++;
-                dlen--;
-            }
-            if (slen <= i) { /* premature end of buf */
-                return EBADMSG;
-            }
-            if (dlen <= 0) { /* not enough memory */
-                return ERANGE; /* not ENOMEM, ERANGE is what glibc looks for */
-            }
-            i++;
-            dlen--;
+            temp = &(pr->buffer[i]);
+            ret = sss_readrep_copy_string(sbuf, &i,
+                                          &slen, &dlen,
+                                          &temp,
+                                          &size);
+            if (ret != EOK) return ret;
 
             /* libc expects NULL instead of empty string */
-            if (strlen(pr->result->val.triple.user) == 0) {
+            if (size == 0) {
                 pr->result->val.triple.user = NULL;
+            } else {
+                pr->result->val.triple.user = temp;
             }
 
             /* Domain value */
-            pr->result->val.triple.domain = &(pr->buffer[i]);
-            while (slen > i && dlen > 0) {
-                pr->buffer[i] = sbuf[i];
-                if (pr->buffer[i] == '\0') break;
-                i++;
-                dlen--;
-            }
-            if (slen <= i) { /* premature end of buf */
-                return EBADMSG;
-            }
-            if (dlen <= 0) { /* not enough memory */
-                return ERANGE; /* not ENOMEM, ERANGE is what glibc looks for */
-            }
-            i++;
-            dlen--;
+            temp = &(pr->buffer[i]);
+            ret = sss_readrep_copy_string(sbuf, &i,
+                                          &slen, &dlen,
+                                          &temp,
+                                          &size);
+            if (ret != EOK) return ret;
 
             /* libc expects NULL instead of empty string */
-            if (strlen(pr->result->val.triple.domain) == 0) {
+            if (size == 0) {
                 pr->result->val.triple.domain = NULL;
+            } else {
+                pr->result->val.triple.domain = temp;
             }
 
             break;
+
         case SSS_NETGR_REP_GROUP:
             pr->result->type = group_val;
 
-            pr->result->val.group = &(pr->buffer[i]);
-            while (slen > i && dlen > 0) {
-                pr->buffer[i] = sbuf[i];
-                if (pr->buffer[i] == '\0') break;
-                i++;
-                dlen--;
-            }
-            if (slen <= i) { /* premature end of buf */
-                return EBADMSG;
-            }
-            if (dlen <= 0) { /* not enough memory */
-                return ERANGE; /* not ENOMEM, ERANGE is what glibc looks for */
-            }
-            i++;
-            dlen--;
+            temp = &(pr->buffer[i]);
+            ret = sss_readrep_copy_string(sbuf, &i,
+                                          &slen, &dlen,
+                                          &temp,
+                                          NULL);
+            if (ret != EOK) return ret;
+
+            pr->result->val.group = temp;
 
             break;
+
         default:
             return EBADMSG;
     }