Arthur de Jong

#include "log.h"

static enum nss_status _nss_ldap_parse_alias(

char *buffer,size_t buflen)

{

struct aliasent *alias=(struct aliasent *)result;

enum nss_status stat;

return stat;

}

{

int stat;

if ((stat=_nss_ldap_write_rndvalue(fp,e,ATM(LM_ALIASES,cn)))!=NSLCD_RESULT_SUCCESS)

#ifdef NEW

static int write_ether(LDAPMessage *e,struct ldap_state *pvt,FILE *fp)

{

int stat;

char buffer[1024];

/* write NSLCD_STRING(ETHER_NAME) */

static enum nss_status

_nss_ldap_parse_ether (LDAPMessage * e,

void *result, char *buffer, size_t buflen)

{

struct ether *ether = (struct ether *) result;

#include "log.h"

#include "cfg.h"

struct name_list

{

char *name;

if (1024<LDAP_NSS_BUFLEN_GROUP)

{

log_log(LOG_CRIT,"allocated buffer in nslcd_group_byname() too small");

}

/* do the LDAP request */

LA_INIT(a);

if (1024<LDAP_NSS_BUFLEN_GROUP)

{

log_log(LOG_CRIT,"allocated buffer in nslcd_group_byname() too small");

}

/* do the LDAP request */

LA_INIT(a);

static void (*__sigpipe_handler) (int) = SIG_DFL;

#endif /* HAVE_SIGACTION */

static const char *_nss_ldap_locate_userpassword (char **vals);

/*

}

#endif /* HAVE_SHADOW_H */

const char *

_nss_ldap_map_at (enum ldap_map_selector sel, const char *attribute)

{

return value;

}

_nss_ldap_map_get (enum ldap_map_selector sel,

enum ldap_map_type type,

const char *from, const char **to)

enum ldap_map_selector sel, /* IN */

const char **user_attrs, /* IN */

int sizelimit, /* IN */

/*

* Emulate X.500 read operation.

*/

enum nss_status _nss_ldap_read (const char *dn, /* IN */

const char **attributes, /* IN */

/*

* extended enumeration routine; uses asynchronous API.

* Caller must have acquired the global mutex

*/

enum nss_status _nss_ldap_getent_ex (struct ldap_args * args, /* IN */

void *result, /* IN/OUT */

char *buffer, /* IN */

size_t buflen, /* IN */

* common enumeration routine; uses asynchronous API.

* Acquires the global mutex

*/

void *result, /* IN/OUT */

char *buffer, /* IN */

size_t buflen, /* IN */

const char *attr, /* IN */

const char *omitvalue, /* IN */

char ***valptr, /* OUT */

size_t * pvalcount /* OUT */ );

int _nss_ldap_shadow_date(const char *val);

void _nss_ldap_shadow_handle_flag(struct spwd *sp);

const char *_nss_ldap_unmap_at (enum ldap_map_selector sel, const char *attribute);

enum nss_status _nss_ldap_init (void);

char _nss_ldap_filt_getaliasbyname[LDAP_FILT_MAXSIZ];

char _nss_ldap_filt_getaliasent[LDAP_FILT_MAXSIZ];

/* MAC address mappings */

char _nss_ldap_filt_gethostton[LDAP_FILT_MAXSIZ];

char _nss_ldap_filt_getntohost[LDAP_FILT_MAXSIZ];

snprintf (_nss_ldap_filt_getaliasent, LDAP_FILT_MAXSIZ,

"(%s=%s)", AT (objectClass), OC (nisMailAlias));

/* MAC address mappings */

snprintf (_nss_ldap_filt_gethostton, LDAP_FILT_MAXSIZ,

"(&(%s=%s)(%s=%s))", AT (objectClass), OC (ieee802Device),

snprintf (_nss_ldap_filt_getnetgrent, LDAP_FILT_MAXSIZ,

"(&(%s=%s)(%s=%s))", AT (objectClass), OC (nisNetgroup),

ATM (LM_NETGROUP, cn), "%s");

}

extern char _nss_ldap_filt_getaliasbyname[];

extern char _nss_ldap_filt_getaliasent[];

/* MAC address mappings */

extern char _nss_ldap_filt_gethostton[];

extern char _nss_ldap_filt_getntohost[];

/* netgroups */

extern char _nss_ldap_filt_getnetgrent[];

/**

* Initialize attribute vector table indexed by map

{

fprintf(stderr,"malloc() failed: %s",strerror(errno));

/* since this is done during initialisation it's best to bail out */

}

tmp->fp=fp;

tmp->loglevel=loglevel;

if (fp==NULL)

{

log_log(LOG_ERR,"cannot open logfile (%s) for appending: %s",filename,strerror(errno));

}

log_addlogging_fp(fp,loglevel);

}

/* thread ids of all running threads */

#define NUM_THREADS 5

/* display version information */

break;

case 'h': /* --help display this help and exit */

display_usage(stdout,argv[0]);

case 'V': /* --version output version information and exit */

display_version(stdout);

case ':': /* missing required parameter */

case '?': /* unknown option character or extraneous parameter */

default:

fprintf(stderr,"Try `%s --help' for more information.\n",

argv[0]);

}

}

/* check for remaining arguments */

argv[0],argv[optind]);

fprintf(stderr,"Try `%s --help' for more information.\n",

argv[0]);

}

}

nslcd_exitsignal=signum;

/* cancel all running threads */

for (i=0;i<NUM_THREADS;i++)

}

if ( (sock=socket(PF_UNIX,SOCK_STREAM,0))<0 )

{

log_log(LOG_ERR,"cannot create socket: %s",strerror(errno));

}

/* remove existing named socket */

strerror(errno));

if (close(sock))

log_log(LOG_WARNING,"problem closing socket: %s",strerror(errno));

}

/* close the file descriptor on exit */

log_log(LOG_ERR,"fctnl(F_SETFL,O_NONBLOCK) failed: %s",strerror(errno));

if (close(sock))

log_log(LOG_WARNING,"problem closing socket: %s",strerror(errno));

}

/* set permissions of socket so anybody can do requests */

{

log_log(LOG_ERR,"fctnl(F_SETFL,O_NONBLOCK) failed: %s",strerror(errno));

if (close(sock))

log_log(LOG_WARNING,"problem closing socket: %s",strerror(errno));

}

/* start listening for connections */

log_log(LOG_ERR,"listen() failed: %s",strerror(errno));

if (close(sock))

log_log(LOG_WARNING,"problem closing socket: %s",strerror(errno));

}

/* we're done */

int32_t tmpint32;

/* read the protocol version */

READ_TYPE(fp,tmpint32,int32_t);

{

log_log(LOG_DEBUG,"wrong nslcd version id (%d)",(int)tmpint32);

return -1;

struct ucred client;

int32_t action;

/* look up process information from client */

if (getsockopt(sock,SOL_SOCKET,SO_PEERCRED,&client,&alen) < 0)

{

log_log(LOG_ERR,"getsockopt(SO_PEERCRED) failed: %s",strerror(errno));

if ((fp=fdopen(sock,"w+"))==NULL)

{

log_log(LOG_WARNING,"cannot create stream for writing: %s",strerror(errno));

return;

}

/* read request */

if (read_header(fp,&action))

{

return;

}

/* handle request */

switch (action)

{

default:

log_log(LOG_WARNING,"invalid request id: %d",(int)action);

break;

}

/* we're done with the request */

return;

}

if ((fp=fopen(filename,"w"))==NULL)

{

log_log(LOG_ERR,"cannot open pid file (%s): %s",filename,strerror(errno));

}

if (fprintf(fp,"%d\n",(int)getpid())<=0)

{

log_log(LOG_ERR,"error writing pid file (%s)",filename);

}

if (fclose(fp))

{

log_log(LOG_ERR,"error writing pid file (%s): %s",filename,strerror(errno));

}

}

}

if (sigaction(signum,&act,NULL)!=0)

{

log_log(LOG_ERR,"error installing signal handler for '%s': %s",signame(signum),strerror(errno));

}

}

/* the main program... */

int main(int argc,char *argv[])

{

int i;

/* parse the command line */

if ((!nslcd_debugging)&&(daemon(0,0)<0))

{

log_log(LOG_ERR,"unable to daemonize: %s",strerror(errno));

}

/* set default mode for pidfile and socket */

/* intilialize logging */

if (!nslcd_debugging)

log_log(LOG_INFO,"version %s starting",VERSION);

/* install handler to close stuff off on exit and log notice */

/* write pidfile */

write_pidfile(NSLCD_PIDFILE);

if (prctl(PR_SET_KEEPCAPS,1))

{

log_log(LOG_ERR,"cannot prctl(PR_SET_KEEPCAPS,1): %s",strerror(errno));

}

log_log(LOG_DEBUG,"debug: prctl(PR_SET_KEEPCAPS,1) done");

/* dump the current capabilities */

if (setgid(mygid)!=0)

{

log_log(LOG_ERR,"cannot setgid(%d): %s",(int)mygid,strerror(errno));

}

log_log(LOG_DEBUG,"debug: setgid(%d) done",mygid);

}

if (setuid(myuid)!=0)

{

log_log(LOG_ERR,"cannot setuid(%d): %s",(int)myuid,strerror(errno));

}

log_log(LOG_DEBUG,"debug: setuid(%d) done",myuid);

}

if (cap_set_proc(mycapabilities)!=0)

{

log_log(LOG_ERR,"cannot cap_set_proc(%s): %s",cap_to_text(mycapabilities,NULL),strerror(errno));

}

log_log(LOG_DEBUG,"debug: cap_set_proc(%2) done",cap_to_text(mycapabilities,NULL));

/* we no longer need this so we should free it */

if (pthread_create(&nslcd_threads[i],NULL,worker,NULL))

{

log_log(LOG_ERR,"unable to start worker thread %d: %s",i,strerror(errno));

}

}

if (pthread_join(nslcd_threads[i],NULL))

{

log_log(LOG_ERR,"unable to wait for worker thread %d: %s",i,strerror(errno));

}

}

signame(nslcd_exitsignal),nslcd_exitsignal);

}

}

struct ldap_state * pvt,

void *result, char *buffer, size_t buflen)

{

struct passwd *pw = (struct passwd *) result;

char *uid, *gid;

enum nss_status stat;

#include "log.h"

static enum nss_status _nss_ldap_parse_proto (LDAPMessage *e,

void *result, char *buffer, size_t buflen)

{

}

static enum nss_status _nss_ldap_parse_rpc (LDAPMessage * e,

void *result, char *buffer, size_t buflen)

{

#include "log.h"

static enum nss_status _nss_ldap_parse_sp(LDAPMessage *e,

void *result,char *buffer,size_t buflen)

{

struct spwd *sp = (struct spwd *) result;

}

static enum nss_status

{

dst->data = malloc (src->size);

if (dst->data == NULL)

static enum nss_status old_dict_put(

struct ldap_dictionary *db,

const struct ldap_datum *key,

const struct ldap_datum *value)

{

return NSS_STATUS_TRYAGAIN;

}

{

do_free_dictionary(q);

return NSS_STATUS_TRYAGAIN;

}

{

do_free_dictionary(q);

return NSS_STATUS_TRYAGAIN;

val.data = (void *) uid;

val.size = strlen (uid);

cache_unlock ();

return NSS_STATUS_SUCCESS;

}

{

enum nss_status status;

*/

enum nss_status _nss_ldap_getrdnvalue(LDAPMessage *entry,

const char *rdntype,

int _nss_ldap_write_rndvalue(FILE *fp,LDAPMessage *entry,const char *rdntype);

* map a distinguished name to a login name, or group entry

*/

enum nss_status _nss_ldap_dn2uid (const char *dn,

int *pIsNestedGroup, LDAPMessage ** pRes);

/*

* Escape '*' in a string for use as a filter

*/

#endif /* _LDAP_NSS_LDAP_UTIL_H */