update C coding style to a more commonly used style

git-svn-id: http://arthurdejong.org/svn/nss-pam-ldapd/nss-pam-ldapd@1873 ef36b2f9-881f-0410-afb5-c4e39611909c
author: Arthur de Jong <arthur@arthurdejong.org> 2012-12-22 22:38:26 +0100
committer: Arthur de Jong <arthur@arthurdejong.org> 2012-12-22 22:38:26 +0100
commit: c7bb19c55c7a902e25bdd33b0d49a2ddcf62e07a (patch)
tree: b3a75ef2719bc2f334041460fd21fbdf86a23a82 /nslcd/passwd.c
parent: d336cd6b429f8ce40c58ea287f79bbc7c23d0966 (diff)
1 files changed, 214 insertions, 218 deletions
diff --git a/nslcd/passwd.c b/nslcd/passwd.c
index 527b83c..a212138 100644
--- a/nslcd/passwd.c
+++ b/nslcd/passwd.c
@@ -66,11 +66,11 @@ const char *attmap_passwd_loginShell    = "loginShell";
 
 /* special properties for objectSid-based searches
    (these are already LDAP-escaped strings) */
-static char *uidSid=NULL;
-static char *gidSid=NULL;
+static char *uidSid = NULL;
+static char *gidSid = NULL;
 
 /* default values for attributes */
-static const char *default_passwd_userPassword     = "*"; /* unmatchable */
+static const char *default_passwd_userPassword = "*"; /* unmatchable */
 
 /* Note that the resulting password value should be one of:
    <empty> - no password set, allow login without password
@@ -80,44 +80,37 @@ static const char *default_passwd_userPassword     = "*"; /* unmatchable */
    other   - encrypted password, usually in crypt(3) format */
 
 /* the attribute list to request with searches */
-static const char **passwd_attrs=NULL;
+static const char **passwd_attrs = NULL;
 
 /* create a search filter for searching a passwd entry
    by name, return -1 on errors */
 static int mkfilter_passwd_byname(const char *name,
-                                  char *buffer,size_t buflen)
+                                  char *buffer, size_t buflen)
 {
   char safename[300];
   /* escape attribute */
-  if(myldap_escape(name,safename,sizeof(safename)))
+  if (myldap_escape(name, safename, sizeof(safename)))
     return -1;
   /* build filter */
-  return mysnprintf(buffer,buflen,
-                    "(&%s(%s=%s))",
-                    passwd_filter,
-                    attmap_passwd_uid,safename);
+  return mysnprintf(buffer, buflen, "(&%s(%s=%s))",
+                    passwd_filter, attmap_passwd_uid, safename);
 }
 
 /* create a search filter for searching a passwd entry
    by uid, return -1 on errors */
-static int mkfilter_passwd_byuid(uid_t uid,
-                                 char *buffer,size_t buflen)
+static int mkfilter_passwd_byuid(uid_t uid, char *buffer, size_t buflen)
 {
-  if (uidSid!=NULL)
+  if (uidSid != NULL)
   {
-    return mysnprintf(buffer,buflen,
-                      "(&%s(%s=%s\\%02x\\%02x\\%02x\\%02x))",
-                      passwd_filter,
-                      attmap_passwd_uidNumber,uidSid,
-                      (int)(uid&0xff),(int)((uid>>8)&0xff),
-                      (int)((uid>>16)&0xff),(int)((uid>>24)&0xff));
+    return mysnprintf(buffer, buflen, "(&%s(%s=%s\\%02x\\%02x\\%02x\\%02x))",
+                      passwd_filter, attmap_passwd_uidNumber, uidSid,
+                      (int)(uid & 0xff), (int)((uid >> 8) & 0xff),
+                      (int)((uid >> 16) & 0xff), (int)((uid >> 24) & 0xff));
   }
   else
   {
-    return mysnprintf(buffer,buflen,
-                      "(&%s(%s=%d))",
-                      passwd_filter,
-                      attmap_passwd_uidNumber,(int)uid);
+    return mysnprintf(buffer, buflen, "(&%s(%s=%d))",
+                      passwd_filter, attmap_passwd_uidNumber, (int)uid);
   }
 }
 
@@ -126,46 +119,45 @@ void passwd_init(void)
   int i;
   SET *set;
   /* set up search bases */
-  if (passwd_bases[0]==NULL)
-    for (i=0;i<NSS_LDAP_CONFIG_MAX_BASES;i++)
-      passwd_bases[i]=nslcd_cfg->ldc_bases[i];
+  if (passwd_bases[0] == NULL)
+    for (i = 0; i < NSS_LDAP_CONFIG_MAX_BASES; i++)
+      passwd_bases[i] = nslcd_cfg->ldc_bases[i];
   /* set up scope */
-  if (passwd_scope==LDAP_SCOPE_DEFAULT)
-    passwd_scope=nslcd_cfg->ldc_scope;
+  if (passwd_scope == LDAP_SCOPE_DEFAULT)
+    passwd_scope = nslcd_cfg->ldc_scope;
   /* special case when uidNumber or gidNumber reference objectSid */
-  if (strncasecmp(attmap_passwd_uidNumber,"objectSid:",10)==0)
+  if (strncasecmp(attmap_passwd_uidNumber, "objectSid:", 10) == 0)
   {
-    uidSid=sid2search(attmap_passwd_uidNumber+10);
-    attmap_passwd_uidNumber=strndup(attmap_passwd_uidNumber,9);
+    uidSid = sid2search(attmap_passwd_uidNumber + 10);
+    attmap_passwd_uidNumber = strndup(attmap_passwd_uidNumber, 9);
   }
-  if (strncasecmp(attmap_passwd_gidNumber,"objectSid:",10)==0)
+  if (strncasecmp(attmap_passwd_gidNumber, "objectSid:", 10) == 0)
   {
-    gidSid=sid2search(attmap_passwd_gidNumber+10);
-    attmap_passwd_gidNumber=strndup(attmap_passwd_gidNumber,9);
+    gidSid = sid2search(attmap_passwd_gidNumber + 10);
+    attmap_passwd_gidNumber = strndup(attmap_passwd_gidNumber, 9);
   }
   /* set up attribute list */
-  set=set_new();
-  attmap_add_attributes(set,"objectClass"); /* for testing shadowAccount */
-  attmap_add_attributes(set,attmap_passwd_uid);
-  attmap_add_attributes(set,attmap_passwd_userPassword);
-  attmap_add_attributes(set,attmap_passwd_uidNumber);
-  attmap_add_attributes(set,attmap_passwd_gidNumber);
-  attmap_add_attributes(set,attmap_passwd_gecos);
-  attmap_add_attributes(set,attmap_passwd_homeDirectory);
-  attmap_add_attributes(set,attmap_passwd_loginShell);
-  passwd_attrs=set_tolist(set);
+  set = set_new();
+  attmap_add_attributes(set, "objectClass"); /* for testing shadowAccount */
+  attmap_add_attributes(set, attmap_passwd_uid);
+  attmap_add_attributes(set, attmap_passwd_userPassword);
+  attmap_add_attributes(set, attmap_passwd_uidNumber);
+  attmap_add_attributes(set, attmap_passwd_gidNumber);
+  attmap_add_attributes(set, attmap_passwd_gecos);
+  attmap_add_attributes(set, attmap_passwd_homeDirectory);
+  attmap_add_attributes(set, attmap_passwd_loginShell);
+  passwd_attrs = set_tolist(set);
   set_free(set);
 }
 
 /* the cache that is used in dn2uid() */
-static pthread_mutex_t dn2uid_cache_mutex=PTHREAD_MUTEX_INITIALIZER;
-static DICT *dn2uid_cache=NULL;
-struct dn2uid_cache_entry
-{
+static pthread_mutex_t dn2uid_cache_mutex = PTHREAD_MUTEX_INITIALIZER;
+static DICT *dn2uid_cache = NULL;
+struct dn2uid_cache_entry {
   time_t timestamp;
   char *uid;
 };
-#define DN2UID_CACHE_TIMEOUT (15*60)
+#define DN2UID_CACHE_TIMEOUT (15 * 60)
 
 /* checks whether the entry has a valid uidNumber attribute
    (>= nss_min_uid) */
@@ -176,39 +168,39 @@ static int entry_has_valid_uid(MYLDAP_ENTRY *entry)
   char *tmp;
   uid_t uid;
   /* if min_uid is not set any entry should do */
-  if (nslcd_cfg->ldc_nss_min_uid==0)
+  if (nslcd_cfg->ldc_nss_min_uid == 0)
     return 1;
   /* get all uidNumber attributes */
-  values=myldap_get_values_len(entry,attmap_passwd_uidNumber);
-  if ((values==NULL)||(values[0]==NULL))
+  values = myldap_get_values_len(entry, attmap_passwd_uidNumber);
+  if ((values == NULL) || (values[0] == NULL))
   {
-    log_log(LOG_WARNING,"%s: %s: missing",
-                        myldap_get_dn(entry),attmap_passwd_uidNumber);
+    log_log(LOG_WARNING, "%s: %s: missing",
+            myldap_get_dn(entry), attmap_passwd_uidNumber);
     return 0;
   }
   /* check if there is a uidNumber attributes >= min_uid */
-  for (i=0;values[i]!=NULL;i++)
+  for (i = 0; values[i] != NULL; i++)
   {
-    if (uidSid!=NULL)
-      uid=(uid_t)binsid2id(values[i]);
+    if (uidSid != NULL)
+      uid = (uid_t)binsid2id(values[i]);
     else
     {
-      errno=0;
-      uid=strtouid(values[i],&tmp,10);
-      if ((*(values[i])=='\0')||(*tmp!='\0'))
+      errno = 0;
+      uid = strtouid(values[i], &tmp, 10);
+      if ((*(values[i]) == '\0') || (*tmp != '\0'))
       {
-        log_log(LOG_WARNING,"%s: %s: non-numeric",
-                            myldap_get_dn(entry),attmap_passwd_uidNumber);
+        log_log(LOG_WARNING, "%s: %s: non-numeric",
+                myldap_get_dn(entry), attmap_passwd_uidNumber);
         continue;
       }
-      else if ((errno!=0)||(strchr(values[i],'-')!=NULL))
+      else if ((errno != 0) || (strchr(values[i], '-') != NULL))
       {
-        log_log(LOG_WARNING,"%s: %s: out of range",
-                            myldap_get_dn(entry),attmap_passwd_uidNumber);
+        log_log(LOG_WARNING, "%s: %s: out of range",
+                myldap_get_dn(entry), attmap_passwd_uidNumber);
         continue;
       }
     }
-    if (uid>=nslcd_cfg->ldc_nss_min_uid)
+    if (uid >= nslcd_cfg->ldc_nss_min_uid)
       return 1;
   }
   /* nothing found */
@@ -217,43 +209,45 @@ static int entry_has_valid_uid(MYLDAP_ENTRY *entry)
 
 /* Perform an LDAP lookup to translate the DN into a uid.
    This function either returns NULL or a strdup()ed string. */
-char *lookup_dn2uid(MYLDAP_SESSION *session,const char *dn,int *rcp,char *buf,size_t buflen)
+char *lookup_dn2uid(MYLDAP_SESSION *session, const char *dn, int *rcp,
+                    char *buf, size_t buflen)
 {
   MYLDAP_SEARCH *search;
   MYLDAP_ENTRY *entry;
   static const char *attrs[3];
-  int rc=LDAP_SUCCESS;
+  int rc = LDAP_SUCCESS;
   const char **values;
-  char *uid=NULL;
-  if (rcp==NULL)
-    rcp=&rc;
+  char *uid = NULL;
+  if (rcp == NULL)
+    rcp = &rc;
   /* we have to look up the entry */
-  attrs[0]=attmap_passwd_uid;
-  attrs[1]=attmap_passwd_uidNumber;
-  attrs[2]=NULL;
-  search=myldap_search(session,dn,LDAP_SCOPE_BASE,passwd_filter,attrs,rcp);
-  if (search==NULL)
+  attrs[0] = attmap_passwd_uid;
+  attrs[1] = attmap_passwd_uidNumber;
+  attrs[2] = NULL;
+  search = myldap_search(session, dn, LDAP_SCOPE_BASE, passwd_filter, attrs, rcp);
+  if (search == NULL)
   {
-    log_log(LOG_WARNING,"%s: lookup error: %s",dn,ldap_err2string(*rcp));
+    log_log(LOG_WARNING, "%s: lookup error: %s", dn, ldap_err2string(*rcp));
     return NULL;
   }
-  entry=myldap_get_entry(search,rcp);
-  if (entry==NULL)
+  entry = myldap_get_entry(search, rcp);
+  if (entry == NULL)
   {
-    if (*rcp!=LDAP_SUCCESS)
-      log_log(LOG_WARNING,"%s: lookup error: %s",dn,ldap_err2string(*rcp));
+    if (*rcp != LDAP_SUCCESS)
+      log_log(LOG_WARNING, "%s: lookup error: %s", dn, ldap_err2string(*rcp));
     return NULL;
   }
   /* check the uidNumber attribute if min_uid is set */
   if (entry_has_valid_uid(entry))
   {
     /* get uid (just use first one) */
-    values=myldap_get_values(entry,attmap_passwd_uid);
+    values = myldap_get_values(entry, attmap_passwd_uid);
     /* check the result for presence and validity */
-    if ((values!=NULL)&&(values[0]!=NULL)&&isvalidname(values[0])&&(strlen(values[0])<buflen))
+    if ((values != NULL) && (values[0] != NULL) &&
+        isvalidname(values[0]) && (strlen(values[0]) < buflen))
     {
-      strcpy(buf,values[0]);
-      uid=buf;
+      strcpy(buf, values[0]);
+      uid = buf;
     }
   }
   /* clean up and return */
@@ -265,15 +259,15 @@ char *lookup_dn2uid(MYLDAP_SESSION *session,const char *dn,int *rcp,char *buf,si
    at getting the user name, including looking in the DN for a uid attribute,
    looking in the cache and falling back to looking up a uid attribute in a
    LDAP query. */
-char *dn2uid(MYLDAP_SESSION *session,const char *dn,char *buf,size_t buflen)
+char *dn2uid(MYLDAP_SESSION *session, const char *dn, char *buf, size_t buflen)
 {
-  struct dn2uid_cache_entry *cacheentry=NULL;
+  struct dn2uid_cache_entry *cacheentry = NULL;
   char *uid;
   /* check for empty string */
-  if ((dn==NULL)||(*dn=='\0'))
+  if ((dn == NULL) || (*dn == '\0'))
     return NULL;
   /* try to look up uid within DN string */
-  if (myldap_cpy_rdn_value(dn,attmap_passwd_uid,buf,buflen)!=NULL)
+  if (myldap_cpy_rdn_value(dn, attmap_passwd_uid, buf, buflen) != NULL)
   {
     /* check if it is valid */
     if (!isvalidname(buf))
@@ -282,17 +276,17 @@ char *dn2uid(MYLDAP_SESSION *session,const char *dn,char *buf,size_t buflen)
   }
   /* see if we have a cached entry */
   pthread_mutex_lock(&dn2uid_cache_mutex);
-  if (dn2uid_cache==NULL)
-    dn2uid_cache=dict_new();
-  if ((dn2uid_cache!=NULL) && ((cacheentry=dict_get(dn2uid_cache,dn))!=NULL))
+  if (dn2uid_cache == NULL)
+    dn2uid_cache = dict_new();
+  if ((dn2uid_cache != NULL) && ((cacheentry = dict_get(dn2uid_cache, dn)) != NULL))
   {
     /* if the cached entry is still valid, return that */
-    if (time(NULL) < (cacheentry->timestamp+DN2UID_CACHE_TIMEOUT))
+    if (time(NULL) < (cacheentry->timestamp + DN2UID_CACHE_TIMEOUT))
     {
-      if ((cacheentry->uid!=NULL)&&(strlen(cacheentry->uid)<buflen))
-        strcpy(buf,cacheentry->uid);
+      if ((cacheentry->uid != NULL) && (strlen(cacheentry->uid) < buflen))
+        strcpy(buf, cacheentry->uid);
       else
-        buf=NULL;
+        buf = NULL;
       pthread_mutex_unlock(&dn2uid_cache_mutex);
       return buf;
     }
@@ -300,33 +294,33 @@ char *dn2uid(MYLDAP_SESSION *session,const char *dn,char *buf,size_t buflen)
   }
   pthread_mutex_unlock(&dn2uid_cache_mutex);
   /* look up the uid using an LDAP query */
-  uid=lookup_dn2uid(session,dn,NULL,buf,buflen);
+  uid = lookup_dn2uid(session, dn, NULL, buf, buflen);
   /* store the result in the cache */
   pthread_mutex_lock(&dn2uid_cache_mutex);
   /* try to get the entry from the cache here again because it could have
      changed in the meantime */
-  cacheentry=dict_get(dn2uid_cache,dn);
-  if (cacheentry==NULL)
+  cacheentry = dict_get(dn2uid_cache, dn);
+  if (cacheentry == NULL)
   {
     /* allocate a new entry in the cache */
-    cacheentry=(struct dn2uid_cache_entry *)malloc(sizeof(struct dn2uid_cache_entry));
-    if (cacheentry!=NULL)
+    cacheentry = (struct dn2uid_cache_entry *)malloc(sizeof(struct dn2uid_cache_entry));
+    if (cacheentry != NULL)
     {
-      cacheentry->uid=NULL;
-      dict_put(dn2uid_cache,dn,cacheentry);
+      cacheentry->uid = NULL;
+      dict_put(dn2uid_cache, dn, cacheentry);
     }
   }
   /* update the cache entry */
-  if (cacheentry!=NULL)
+  if (cacheentry != NULL)
   {
-    cacheentry->timestamp=time(NULL);
+    cacheentry->timestamp = time(NULL);
     /* copy the uid if needed */
-    if (cacheentry->uid==NULL)
-      cacheentry->uid=uid!=NULL?strdup(uid):NULL;
-    else if ((uid==NULL)||(strcmp(cacheentry->uid,uid)!=0))
+    if (cacheentry->uid == NULL)
+      cacheentry->uid = uid != NULL ? strdup(uid) : NULL;
+    else if ((uid == NULL) || (strcmp(cacheentry->uid, uid) != 0))
     {
       free(cacheentry->uid);
-      cacheentry->uid=uid!=NULL?strdup(uid):NULL;
+      cacheentry->uid = uid != NULL ? strdup(uid) : NULL;
     }
   }
   pthread_mutex_unlock(&dn2uid_cache_mutex);
@@ -334,10 +328,10 @@ char *dn2uid(MYLDAP_SESSION *session,const char *dn,char *buf,size_t buflen)
   return uid;
 }
 
-MYLDAP_ENTRY *uid2entry(MYLDAP_SESSION *session,const char *uid,int *rcp)
+MYLDAP_ENTRY *uid2entry(MYLDAP_SESSION *session, const char *uid, int *rcp)
 {
-  MYLDAP_SEARCH *search=NULL;
-  MYLDAP_ENTRY *entry=NULL;
+  MYLDAP_SEARCH *search = NULL;
+  MYLDAP_ENTRY *entry = NULL;
   const char *base;
   int i;
   static const char *attrs[3];
@@ -345,43 +339,43 @@ MYLDAP_ENTRY *uid2entry(MYLDAP_SESSION *session,const char *uid,int *rcp)
   /* if it isn't a valid username, just bail out now */
   if (!isvalidname(uid))
   {
-    if (rcp!=NULL)
-      *rcp=LDAP_INVALID_SYNTAX;
+    if (rcp != NULL)
+      *rcp = LDAP_INVALID_SYNTAX;
     return NULL;
   }
   /* set up attributes (we don't need much) */
-  attrs[0]=attmap_passwd_uid;
-  attrs[1]=attmap_passwd_uidNumber;
-  attrs[2]=NULL;
+  attrs[0] = attmap_passwd_uid;
+  attrs[1] = attmap_passwd_uidNumber;
+  attrs[2] = NULL;
   /* we have to look up the entry */
-  mkfilter_passwd_byname(uid,filter,sizeof(filter));
-  for (i=0;(i<NSS_LDAP_CONFIG_MAX_BASES)&&((base=passwd_bases[i])!=NULL);i++)
+  mkfilter_passwd_byname(uid, filter, sizeof(filter));
+  for (i = 0; (i < NSS_LDAP_CONFIG_MAX_BASES) && ((base = passwd_bases[i]) != NULL); i++)
   {
-    search=myldap_search(session,base,passwd_scope,filter,attrs,rcp);
-    if (search==NULL)
+    search = myldap_search(session, base, passwd_scope, filter, attrs, rcp);
+    if (search == NULL)
     {
-      if ((rcp!=NULL)&&(*rcp==LDAP_SUCCESS))
-        *rcp=LDAP_NO_SUCH_OBJECT;
+      if ((rcp != NULL) && (*rcp == LDAP_SUCCESS))
+        *rcp = LDAP_NO_SUCH_OBJECT;
       return NULL;
     }
-    entry=myldap_get_entry(search,rcp);
-    if ((entry!=NULL)&&(entry_has_valid_uid(entry)))
+    entry = myldap_get_entry(search, rcp);
+    if ((entry != NULL) && (entry_has_valid_uid(entry)))
       return entry;
   }
-  if ((rcp!=NULL)&&(*rcp==LDAP_SUCCESS))
-    *rcp=LDAP_NO_SUCH_OBJECT;
+  if ((rcp != NULL) && (*rcp == LDAP_SUCCESS))
+    *rcp = LDAP_NO_SUCH_OBJECT;
   return NULL;
 }
 
-char *uid2dn(MYLDAP_SESSION *session,const char *uid,char *buf,size_t buflen)
+char *uid2dn(MYLDAP_SESSION *session, const char *uid, char *buf, size_t buflen)
 {
   MYLDAP_ENTRY *entry;
   /* look up the entry */
-  entry=uid2entry(session,uid,NULL);
-  if (entry==NULL)
+  entry = uid2entry(session, uid, NULL);
+  if (entry == NULL)
     return NULL;
   /* get DN */
-  return myldap_cpy_dn(entry,buf,buflen);
+  return myldap_cpy_dn(entry, buf, buflen);
 }
 
 #ifndef NSS_FLAVOUR_GLIBC
@@ -393,8 +387,8 @@ char *uid2dn(MYLDAP_SESSION *session,const char *uid,char *buf,size_t buflen)
 /* the maximum number of uidNumber attributes per entry */
 #define MAXUIDS_PER_ENTRY 5
 
-static int write_passwd(TFILE *fp,MYLDAP_ENTRY *entry,const char *requser,
-                        const uid_t *requid,uid_t calleruid)
+static int write_passwd(TFILE *fp, MYLDAP_ENTRY *entry, const char *requser,
+                        const uid_t *requid, uid_t calleruid)
 {
   int32_t tmpint32;
   const char **tmpvalues;
@@ -409,133 +403,134 @@ static int write_passwd(TFILE *fp,MYLDAP_ENTRY *entry,const char *requser,
   char homedir[256];
   char shell[64];
   char passbuffer[64];
-  int i,j;
+  int i, j;
   /* get the usernames for this entry */
-  usernames=myldap_get_values(entry,attmap_passwd_uid);
-  if ((usernames==NULL)||(usernames[0]==NULL))
+  usernames = myldap_get_values(entry, attmap_passwd_uid);
+  if ((usernames == NULL) || (usernames[0] == NULL))
   {
-    log_log(LOG_WARNING,"%s: %s: missing",
-                        myldap_get_dn(entry),attmap_passwd_uid);
+    log_log(LOG_WARNING, "%s: %s: missing",
+            myldap_get_dn(entry), attmap_passwd_uid);
     return 0;
   }
   /* if we are using shadow maps and this entry looks like it would return
      shadow information, make the passwd entry indicate it */
-  if (myldap_has_objectclass(entry,"shadowAccount")&&nsswitch_shadow_uses_ldap())
+  if (myldap_has_objectclass(entry, "shadowAccount") && nsswitch_shadow_uses_ldap())
   {
-    passwd="x";
+    passwd = "x";
   }
   else
   {
-    passwd=get_userpassword(entry,attmap_passwd_userPassword,passbuffer,sizeof(passbuffer));
-    if ((passwd==NULL)||(calleruid!=0))
-      passwd=default_passwd_userPassword;
+    passwd = get_userpassword(entry, attmap_passwd_userPassword,
+                              passbuffer, sizeof(passbuffer));
+    if ((passwd == NULL) || (calleruid != 0))
+      passwd = default_passwd_userPassword;
   }
   /* get the uids for this entry */
-  if (requid!=NULL)
+  if (requid != NULL)
   {
-    uids[0]=*requid;
-    numuids=1;
+    uids[0] = *requid;
+    numuids = 1;
   }
   else
   {
-    tmpvalues=myldap_get_values_len(entry,attmap_passwd_uidNumber);
-    if ((tmpvalues==NULL)||(tmpvalues[0]==NULL))
+    tmpvalues = myldap_get_values_len(entry, attmap_passwd_uidNumber);
+    if ((tmpvalues == NULL) || (tmpvalues[0] == NULL))
     {
-      log_log(LOG_WARNING,"%s: %s: missing",
-                          myldap_get_dn(entry),attmap_passwd_uidNumber);
+      log_log(LOG_WARNING, "%s: %s: missing",
+              myldap_get_dn(entry), attmap_passwd_uidNumber);
       return 0;
     }
-    for (numuids=0;(numuids<MAXUIDS_PER_ENTRY)&&(tmpvalues[numuids]!=NULL);numuids++)
+    for (numuids = 0; (numuids < MAXUIDS_PER_ENTRY) && (tmpvalues[numuids] != NULL); numuids++)
     {
-      if (uidSid!=NULL)
-        uids[numuids]=(uid_t)binsid2id(tmpvalues[numuids]);
+      if (uidSid != NULL)
+        uids[numuids] = (uid_t)binsid2id(tmpvalues[numuids]);
       else
       {
-        errno=0;
-        uids[numuids]=strtouid(tmpvalues[numuids],&tmp,10);
-        if ((*(tmpvalues[numuids])=='\0')||(*tmp!='\0'))
+        errno = 0;
+        uids[numuids] = strtouid(tmpvalues[numuids], &tmp, 10);
+        if ((*(tmpvalues[numuids]) == '\0') || (*tmp != '\0'))
         {
-          log_log(LOG_WARNING,"%s: %s: non-numeric",
-                              myldap_get_dn(entry),attmap_passwd_uidNumber);
+          log_log(LOG_WARNING, "%s: %s: non-numeric",
+                  myldap_get_dn(entry), attmap_passwd_uidNumber);
           return 0;
         }
-        else if ((errno!=0)||(strchr(tmpvalues[numuids],'-')!=NULL))
+        else if ((errno != 0) || (strchr(tmpvalues[numuids], '-') != NULL))
         {
-          log_log(LOG_WARNING,"%s: %s: out of range",
-                              myldap_get_dn(entry),attmap_passwd_uidNumber);
+          log_log(LOG_WARNING, "%s: %s: out of range",
+                  myldap_get_dn(entry), attmap_passwd_uidNumber);
           return 0;
         }
       }
     }
   }
   /* get the gid for this entry */
-  if (gidSid!=NULL)
+  if (gidSid != NULL)
   {
-    tmpvalues=myldap_get_values_len(entry,attmap_passwd_gidNumber);
-    if ((tmpvalues==NULL)||(tmpvalues[0]==NULL))
+    tmpvalues = myldap_get_values_len(entry, attmap_passwd_gidNumber);
+    if ((tmpvalues == NULL) || (tmpvalues[0] == NULL))
     {
-      log_log(LOG_WARNING,"%s: %s: missing",
-                          myldap_get_dn(entry),attmap_passwd_gidNumber);
+      log_log(LOG_WARNING, "%s: %s: missing",
+              myldap_get_dn(entry), attmap_passwd_gidNumber);
       return 0;
     }
-    gid=(gid_t)binsid2id(tmpvalues[0]);
+    gid = (gid_t)binsid2id(tmpvalues[0]);
   }
   else
   {
-    attmap_get_value(entry,attmap_passwd_gidNumber,gidbuf,sizeof(gidbuf));
-    if (gidbuf[0]=='\0')
+    attmap_get_value(entry, attmap_passwd_gidNumber, gidbuf, sizeof(gidbuf));
+    if (gidbuf[0] == '\0')
     {
-      log_log(LOG_WARNING,"%s: %s: missing",
-                          myldap_get_dn(entry),attmap_passwd_gidNumber);
+      log_log(LOG_WARNING, "%s: %s: missing",
+              myldap_get_dn(entry), attmap_passwd_gidNumber);
       return 0;
     }
-    errno=0;
-    gid=strtogid(gidbuf,&tmp,10);
-    if ((gidbuf[0]=='\0')||(*tmp!='\0'))
+    errno = 0;
+    gid = strtogid(gidbuf, &tmp, 10);
+    if ((gidbuf[0] == '\0') || (*tmp != '\0'))
     {
-      log_log(LOG_WARNING,"%s: %s: non-numeric",
-                          myldap_get_dn(entry),attmap_passwd_gidNumber);
+      log_log(LOG_WARNING, "%s: %s: non-numeric",
+              myldap_get_dn(entry), attmap_passwd_gidNumber);
       return 0;
     }
-    else if ((errno!=0)||(strchr(gidbuf,'-')!=NULL))
+    else if ((errno != 0) || (strchr(gidbuf, '-') != NULL))
     {
-      log_log(LOG_WARNING,"%s: %s: out of range",
-                          myldap_get_dn(entry),attmap_passwd_gidNumber);
+      log_log(LOG_WARNING, "%s: %s: out of range",
+              myldap_get_dn(entry), attmap_passwd_gidNumber);
       return 0;
     }
   }
   /* get the gecos for this entry */
-  attmap_get_value(entry,attmap_passwd_gecos,gecos,sizeof(gecos));
+  attmap_get_value(entry, attmap_passwd_gecos, gecos, sizeof(gecos));
   /* get the home directory for this entry */
-  attmap_get_value(entry,attmap_passwd_homeDirectory,homedir,sizeof(homedir));
-  if (homedir[0]=='\0')
-    log_log(LOG_WARNING,"%s: %s: missing",
-                        myldap_get_dn(entry),attmap_passwd_homeDirectory);
+  attmap_get_value(entry, attmap_passwd_homeDirectory, homedir, sizeof(homedir));
+  if (homedir[0] == '\0')
+    log_log(LOG_WARNING, "%s: %s: missing",
+            myldap_get_dn(entry), attmap_passwd_homeDirectory);
   /* get the shell for this entry */
-  attmap_get_value(entry,attmap_passwd_loginShell,shell,sizeof(shell));
+  attmap_get_value(entry, attmap_passwd_loginShell, shell, sizeof(shell));
   /* write the entries */
-  for (i=0;usernames[i]!=NULL;i++)
-    if ((requser==NULL)||(STR_CMP(requser,usernames[i])==0))
+  for (i = 0; usernames[i] != NULL; i++)
+    if ((requser == NULL) || (STR_CMP(requser, usernames[i]) == 0))
     {
       if (!isvalidname(usernames[i]))
       {
-        log_log(LOG_WARNING,"%s: %s: denied by validnames option",
-                            myldap_get_dn(entry),attmap_passwd_uid);
+        log_log(LOG_WARNING, "%s: %s: denied by validnames option",
+                myldap_get_dn(entry), attmap_passwd_uid);
       }
       else
       {
-        for (j=0;j<numuids;j++)
+        for (j = 0; j < numuids; j++)
         {
-          if (uids[j]>=nslcd_cfg->ldc_nss_min_uid)
+          if (uids[j] >= nslcd_cfg->ldc_nss_min_uid)
           {
-            WRITE_INT32(fp,NSLCD_RESULT_BEGIN);
-            WRITE_STRING(fp,usernames[i]);
-            WRITE_STRING(fp,passwd);
-            WRITE_INT32(fp,uids[j]);
-            WRITE_INT32(fp,gid);
-            WRITE_STRING(fp,gecos);
-            WRITE_STRING(fp,homedir);
-            WRITE_STRING(fp,shell);
+            WRITE_INT32(fp, NSLCD_RESULT_BEGIN);
+            WRITE_STRING(fp, usernames[i]);
+            WRITE_STRING(fp, passwd);
+            WRITE_INT32(fp, uids[j]);
+            WRITE_INT32(fp, gid);
+            WRITE_STRING(fp, gecos);
+            WRITE_STRING(fp, homedir);
+            WRITE_STRING(fp, shell);
           }
         }
       }
@@ -544,47 +539,48 @@ static int write_passwd(TFILE *fp,MYLDAP_ENTRY *entry,const char *requser,
 }
 
 NSLCD_HANDLE_UID(
-  passwd,byname,
+  passwd, byname,
   char name[256];
   char filter[4096];
-  READ_STRING(fp,name);
-  log_setrequest("passwd=\"%s\"",name);
-  if (!isvalidname(name)) {
-    log_log(LOG_WARNING,"request denied by validnames option");
+  READ_STRING(fp, name);
+  log_setrequest("passwd=\"%s\"", name);
+  if (!isvalidname(name))
+  {
+    log_log(LOG_WARNING, "request denied by validnames option");
     return -1;
   }
   nsswitch_check_reload();,
   NSLCD_ACTION_PASSWD_BYNAME,
-  mkfilter_passwd_byname(name,filter,sizeof(filter)),
-  write_passwd(fp,entry,name,NULL,calleruid)
+  mkfilter_passwd_byname(name, filter, sizeof(filter)),
+  write_passwd(fp, entry, name, NULL, calleruid)
 )
 
 NSLCD_HANDLE_UID(
-  passwd,byuid,
+  passwd, byuid,
   uid_t uid;
   char filter[4096];
-  READ_INT32(fp,uid);
-  log_setrequest("passwd=%lu",(unsigned long int)uid);
-  if (uid<nslcd_cfg->ldc_nss_min_uid)
+  READ_INT32(fp, uid);
+  log_setrequest("passwd=%lu", (unsigned long int)uid);
+  if (uid < nslcd_cfg->ldc_nss_min_uid)
   {
     /* return an empty result */
-    WRITE_INT32(fp,NSLCD_VERSION);
-    WRITE_INT32(fp,NSLCD_ACTION_PASSWD_BYUID);
-    WRITE_INT32(fp,NSLCD_RESULT_END);
+    WRITE_INT32(fp, NSLCD_VERSION);
+    WRITE_INT32(fp, NSLCD_ACTION_PASSWD_BYUID);
+    WRITE_INT32(fp, NSLCD_RESULT_END);
     return 0;
   }
   nsswitch_check_reload();,
   NSLCD_ACTION_PASSWD_BYUID,
-  mkfilter_passwd_byuid(uid,filter,sizeof(filter)),
-  write_passwd(fp,entry,NULL,&uid,calleruid)
+  mkfilter_passwd_byuid(uid, filter, sizeof(filter)),
+  write_passwd(fp, entry, NULL, &uid, calleruid)
 )
 
 NSLCD_HANDLE_UID(
-  passwd,all,
+  passwd, all,
   const char *filter;
   log_setrequest("passwd(all)");
   nsswitch_check_reload();,
   NSLCD_ACTION_PASSWD_ALL,
-  (filter=passwd_filter,0),
-  write_passwd(fp,entry,NULL,NULL,calleruid)
+  (filter = passwd_filter, 0),
+  write_passwd(fp, entry, NULL, NULL, calleruid)
 )
author	Arthur de Jong <arthur@arthurdejong.org>	2012-12-22 22:38:26 +0100
committer	Arthur de Jong <arthur@arthurdejong.org>	2012-12-22 22:38:26 +0100
commit	c7bb19c55c7a902e25bdd33b0d49a2ddcf62e07a (patch)
tree	b3a75ef2719bc2f334041460fd21fbdf86a23a82 /nslcd/passwd.c
parent	d336cd6b429f8ce40c58ea287f79bbc7c23d0966 (diff)