/*
    ncpreadprops - print a list of NDS properties of current user
    Copyright (C) 2001 by Patrick Pollet

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


    Revision history: 

        1.00 2001   Nov 02             Patrick Pollet <patrick.pollet@insa-lyon.fr>
                the program is an extension of ncpreadprop to allow:
		   a list of NDS properties
                             a separator between them
         the first idea was to put in the attribute buffer the list of requested attributes:
            IT WORKS BUT NDS does not return attributes in the same order
example:
 ./ncpreadprops -o ppollet -A "Postal Address,Full Name,LINUX:uid,Home Directory,CN" -c PC
-->
Ppollet:0 CN=FCPC2_APPS home\ppollet:1 2 3 4 5 6:Patrick Pollet:9999

	1.01 2001   Nov 03             Patrick Pollet <patrick.pollet@insa-lyon.fr>
		we call ReadAttributeValue for every attribute of the list !!!

	1.02  2001 Dec 16		Petr Vandrovec <vandrove@vc.cvut.cz>
		const <-> non const pointers cleanup

	1.03  2002 June 6		Patrick Pollet <patrick.pollet@insa-lyon.fr>
		emission of separator between multiple values

	1.04  2002 Sept 16		Patrick Pollet <patrick.pollet@insa-lyon.fr>
		emission of separator between multiple values when attributes are not read at once

 */



#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>

#include <sys/errno.h>
#include <ncp/nwcalls.h>
#include <ncp/nwnet.h>
#include <ncp/nwclient.h>

#include <pwd.h>

#include "getopt.h"

#include "private/libintl.h"
#define _(X) X

static char *progname;

static void __attribute__((noreturn))
usage(void)
{
	fprintf(stderr, _("usage: %s [options] \n"), progname);
        exit(1);
}

static void
help(void)
{
	printf(_("\n"
		 "usage: %s [options] \n"), progname);
	printf(_("\n"
	       "-h                  Print this help text\n"
               "-o  object_name   Mandatory: Object name  \n"
               "-A  attribute_liste  Mandatory: One NDS attribute or a comma separated list\n"
               "-T  treename       \n"
               "-c  context        Default= [root]\n"
               "-v  value          Context DCK_FLAGS default=0 \n"
               "-f  character      separator between attributes (default= :)\n"
	  "-m  character       separator between values of multi-valued attributes (default = space) \n"
	       "\n"));
        exit(1);
}




static int doPrintOut (NWDSContextHandle ctx, const void * name, const enum SYNTAX synt, char sep ) {
/* do not emit CR here */
/* sep is the caracter used to separate multiples values such as postal address or home directory*/
  (void) ctx;
  switch (synt) {
	case SYN_DIST_NAME:
	case SYN_CI_STRING:
	case SYN_CE_STRING:
        case SYN_PR_STRING:
	case SYN_NU_STRING:
	case SYN_TEL_NUMBER:
	case SYN_CLASS_NAME:
		printf("%s", (const char*)name);
	        break;
	case SYN_OCTET_STRING:{
	        const Octet_String_T* os = (const Octet_String_T*)name;
		size_t i;
		printf("%u%c", os->length,sep);
		for (i = 0; i < os->length; i++)
			printf("%02X%c", os->data[i],sep);
		}
		break;
	case SYN_COUNTER:
	case SYN_INTEGER:
	case SYN_INTERVAL:
		printf("%u", *((const Integer_T*)name));
        	break;
	case SYN_BOOLEAN:{
	        const Boolean_T* b = (const Boolean_T*)name;
		printf("%s", (*b==1)?"true":(*b)?"unknown":"false");
		}
		break;
	case SYN_TIMESTAMP:{
		const TimeStamp_T* stamp = (const TimeStamp_T*)name;
                printf("%u%c%u%c%u",stamp->wholeSeconds,sep, stamp->replicaNum,sep,stamp->eventID);
		}
		break;
	case SYN_NET_ADDRESS:{
		const Net_Address_T* na = (const Net_Address_T*)name;
	        size_t z;
		printf("%u%c%u%c", na->addressType,sep,na->addressLength,sep);
		for (z = 0; z < na->addressLength; z++)
			printf("%02X%c", na->address[z],sep);
		}
		break;
	case SYN_OBJECT_ACL:{
	        const Object_ACL_T* oacl = (const Object_ACL_T*)name;
		printf("%s%c%s%c%08x", oacl->protectedAttrName,sep,oacl->subjectName,sep,oacl->privileges);
		}
		break;
	case SYN_PATH:{
	        const Path_T* p = (const Path_T*)name;
		printf("%u%c%s%c%s", p->nameSpaceType,sep,p->volumeName,sep, p->path);
		}
		break;
	case SYN_TIME:{
		printf("%s", ctime((const Time_T*)name));
                }
		break;
	case SYN_TYPED_NAME:{
		const Typed_Name_T* tn = (const Typed_Name_T*)name;
		printf("%u%c%u%c%s", tn->interval,sep, tn->level,sep, tn->objectName);
		}
		break;
	case SYN_CI_LIST:{
	        const CI_List_T* cl = (const CI_List_T*)name;
		for (; cl; cl = cl->next)
			printf("%s", cl->s);
		}
		break;
	case SYN_OCTET_LIST:{
	        const Octet_List_T* ol = (const Octet_List_T*)name;
		for (; ol; ol = ol->next) {
		        size_t i;
		        printf("%u%c", ol->length,sep);
			for (i = 0; i < ol->length; i++)
				printf("%02X%c", ol->data[i],sep);
		}
		}
		break;
	case SYN_BACK_LINK:{
	        const Back_Link_T* bl = (const Back_Link_T*)name;
		printf("%08X%c%s", bl->remoteID, sep,bl->objectName);
	        }
		break;
	case SYN_FAX_NUMBER:{
	        const Fax_Number_T* fn = (const Fax_Number_T*)name;
		printf("%s%c%u", fn->telephoneNumber, sep,fn->parameters.numOfBits);
		}
		break;
	case SYN_EMAIL_ADDRESS:{
		const EMail_Address_T* ea = (const EMail_Address_T*)name;
		printf("%u%c%s", ea->type, sep,ea->address);
		}
		break;
	case SYN_PO_ADDRESS:{
		const NWDSChar*const* pa = (const NWDSChar*const*)name;
		printf("%s%c%s%c%s%c%s%c%s%c%s",pa[0],sep,pa[1],sep,pa[2],sep,pa[3],sep,pa[4],sep,pa[5]);
		}
		break;
	case SYN_HOLD:{
	        const Hold_T* h = (const Hold_T*)name;
		printf("%u%c%s", h->amount,sep,h->objectName);
		}
		break;
	default:
	        printf(" *** ");  /* don't mess up display */
		return 1;
	}

        return 0;


}

static NWCCODE readAttributeValue( NWDSContextHandle ctx, char * objName,char *attrName, char sepvalue) {

        Buf_T* inbuf=NULL;
       	Buf_T* outbuf=NULL;
        NWDSCCODE dserr;
	nuint32 iterHandle;

	size_t size = DEFAULT_MESSAGE_LEN;

        iterHandle = NO_MORE_ITERATIONS; /*test at bailout point */

        dserr = NWDSAllocBuf(size, &inbuf);
	if (dserr) {
		fprintf(stderr, "NWDSAllocBuf() failed with %s\n", strnwerror(dserr));
		goto bailout;
	}
	dserr = NWDSInitBuf(ctx, DSV_READ, inbuf);
	if (dserr) {
		fprintf(stderr, "NWDSInitBuf() failed with %s\n", strnwerror(dserr));
		goto bailout;
	}

                dserr = NWDSPutAttrName(ctx, inbuf, attrName);
                if (dserr) {
		fprintf(stderr, "NWDSPutAttrName(%s) failed with %s\n", attrName, strnwerror(dserr));
		goto bailout;
	}



	dserr = NWDSAllocBuf(size, &outbuf);
	if (dserr) {
		fprintf(stderr, "NWDSAllocBuf() failed with %s\n", strnwerror(dserr));
		goto bailout;
	}
	do {
		NWObjectCount attrs;

		dserr = NWDSRead(ctx, objName, DS_ATTRIBUTE_VALUES, 0, inbuf, &iterHandle, outbuf);
		if (dserr) {
			if (dserr == ERR_NO_SUCH_ATTRIBUTE) {
                               	/*fprintf(stderr, "NWDSRead() failed with %s\n", strnwerror(dserr));*/
				dserr = 0;
                        }
			else
				fprintf(stderr, "NWDSRead() failed with %s\n", strnwerror(dserr));
			goto bailout;
		}
		dserr = NWDSGetAttrCount(ctx, outbuf, &attrs);
		if (dserr) {
			fprintf(stderr, "NWDSGetAttrCount() failed with %s\n", strnwerror(dserr));
			goto bailout;
		}
                /*fprintf(stderr, "%d attributes found\n", attrs);*/
		while (attrs--) {
			NWDSChar attrname[MAX_SCHEMA_NAME_CHARS+1];
			enum SYNTAX synt;
			NWObjectCount vals;

			dserr = NWDSGetAttrName(ctx, outbuf, attrname, &vals, &synt);
			if (dserr) {
				fprintf(stderr, "NWDSGetAttrName() failed with %s\n", strnwerror(dserr));
				goto bailout;
			}
			/*fprintf(stderr, "%d values found\n", vals);*/
			while (vals--) {
				size_t sz;
				void* val;

				dserr = NWDSComputeAttrValSize(ctx, outbuf, synt, &sz);
				if (dserr) {
					fprintf(stderr, "NWDSComputeAttrValSize() failed with %s\n", strnwerror(dserr));
					goto bailout;
				}
				val = malloc(sz);
				if (!val) {
					fprintf(stderr, "malloc() failed with %s\n", strnwerror(ENOMEM));
					goto bailout;
				}
				dserr = NWDSGetAttrVal(ctx,outbuf, synt, val);
				if (dserr) {
					free(val);
					fprintf(stderr, "NWDSGetAttrVal() failed with %s\n", strnwerror(dserr));
					goto bailout;
				}
				dserr=doPrintOut (ctx,val,synt,sepvalue);

				free(val);
				if (dserr) {
                                        fprintf(stderr, "doPrintOut failed with %s\n", strnwerror(dserr));
					goto bailout;
				}
				if ((vals) || (iterHandle != NO_MORE_ITERATIONS))
					printf("%c", sepvalue); /* emit separator between values */
			}

		}
	} while (iterHandle != NO_MORE_ITERATIONS);
bailout:;

	if (iterHandle != NO_MORE_ITERATIONS) {
        /*  let's keep the final dserr as the real one */
		NWDSCCODE dserr2 = NWDSCloseIteration(ctx, DSV_READ, iterHandle);
		if (dserr2) {
			fprintf(stderr, "NWDSCloseIteration() failed with %s\n", strnwerror(dserr2));
		}
	}
	if (inbuf) NWDSFreeBuf(inbuf);
	if (outbuf) NWDSFreeBuf(outbuf);
	return dserr;
}

static NWCCODE readAttributesValues( NWDSContextHandle ctx, char * objName,char *attrName, char sepvalue, char sepattr) {
/* scan the list of attributes*/
	   char  attrBuf[MAX_DN_CHARS+1];
	   const char * attrStart;
	   const char * attrEnd;

        attrStart=attrName;
        do {
                if (attrStart) {
                        attrEnd=strchr(attrStart,',');
                        if (attrEnd) {
                               memcpy(attrBuf,attrStart,attrEnd - attrStart);
                               attrBuf[attrEnd-attrStart]=0;
                               attrEnd++;
                        }  else
                                strcpy(attrBuf,attrStart);
                        attrStart=attrEnd;
                }
                readAttributeValue(ctx, objName,attrBuf, sepvalue);
                if (attrStart)   printf("%c",sepattr);  /* emit separator exepct after the last attribute*/
        } while (attrStart);
          printf("\n"); /* change line here */
        return 0;
}

int
main(int argc, char *argv[])
{
	long err;
	int opt;
	char * objectName=NULL;
	char * attributeName=NULL;
	const char * contextName="[Root]";
	char * server=NULL;
	char sepvalue=' ';  /*default separator between multiple values is space */
	char sepattr=':';     /* default separator between attributes is :*/



        NWDSContextHandle ctx=NULL;
	NWCONN_HANDLE conn=NULL;
        NWDSCCODE dserr,dserr2;
        u_int32_t ctxflag = 0;

        char     treeName    [MAX_TREE_NAME_CHARS +1]="";

        progname = argv[0];

        NWCallsInit(NULL, NULL);
#ifndef N_PLAT_MSW4
	NWDSInitRequester();
#else
        setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, LOCALEDIR);
	textdomain(PACKAGE);
#endif


       	while ((opt = getopt(argc, argv, "h?o:A:T:c:S:v:f:m:")) != EOF)
	{
		switch (opt)
		{
		case 'h':
		case '?':
			help();
                case 'A':
                        attributeName=optarg;
                  break;
                case 'T':
                       if (strlen(optarg) <sizeof(treeName))
                                strcpy(treeName,optarg);
                       else {
                                fprintf(stderr,"failed:parameter treename is too long.\n");
                                exit(3);
                       }
                  break;
                case 'o':
                        objectName=optarg;
                  break;
                case 'c':
                        contextName=optarg;
                  break;
               	case 'S':
	        	server = optarg;
                  break;
  	case 'f':
	        	sepattr = optarg[0];
                  break;
	      case 'm':
	        	sepvalue = optarg[0];
                  break;
                case 'v':
                        ctxflag = strtoul(optarg, NULL, 0);
		break;

		default:
			usage();
		}
	}

	if (optind != argc) {
                printf ("failed %d %d",optind,argc);
		usage();
		exit(1);
	}

        if (!attributeName) {
            fprintf(stderr,"failed:you must specify an attribut name.\n");
            exit(2);
        }
        if (!objectName) {
            fprintf(stderr,"failed:you must specify a NDS object name.\n");
            exit(2);
        }
        if (server && treeName[0]) {
          	fprintf(stderr, "failed:cannot have both -T tree and -S server options\n");
		exit(101);
        }



        { /*tested code goes here */
          u_int32_t init_ctxflag ;

        dserr = NWDSCreateContextHandle(&ctx);
	if (dserr) {
		fprintf(stderr, "NWDSCreateContextHandle failed with %s\n", strnwerror(dserr));
		goto bailout;
	}





        dserr = NWDSGetContext(ctx, DCK_FLAGS, &init_ctxflag);
	if (dserr) {
		fprintf(stderr, "NWDSGetContext(DCK_FLAGS) failed: %s\n",
			strnwerror(dserr));
		goto bailout;
	}
       init_ctxflag |= DCV_XLATE_STRINGS+ctxflag;

	dserr = NWDSSetContext(ctx, DCK_FLAGS, &init_ctxflag);
	if (dserr) {
		fprintf(stderr, "NWDSSetContext(DCK_FLAGS) failed: %s\n",
			strnwerror(dserr));
		goto bailout;
	}
	dserr = NWDSSetContext(ctx, DCK_NAME_CONTEXT, contextName);
	if (dserr) {
		fprintf(stderr, "NWDSSetContext(DCK_NAME_CONTEXT) failed: %s\n",
			strnwerror(dserr));
        	goto bailout;
	}

#ifndef N_PLAT_MSW4
	{
		static const NET_ADDRESS_TYPE add[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
		dserr = NWDSSetTransport(ctx, 16, add);
		if (dserr) {
			fprintf(stderr, "NWDSSetTransport failed: %s\n",
				strnwerror(dserr));
			goto bailout;
		}
	}
#endif
#ifdef N_PLAT_MSW4
	dserr = NWDSOpenConnToNDSServer(ctx, server, &conn);
#else
	if (server) {
          if  (server[0] == '/') {
		dserr = ncp_open_mount(server, &conn);
		if (dserr) {
			fprintf(stderr, "ncp_open_mount failed with %s\n",
				strnwerror(dserr));
			goto bailout;
		}
	  } else {
		struct ncp_conn_spec connsp;
		memset(&connsp, 0, sizeof(connsp));
		strcpy(connsp.server, server);
		conn = ncp_open(&connsp, &err);
            }
        } else {
                if (!treeName[0]) {
                         NWCXGetPreferredDSTree(treeName,sizeof(treeName));

                }
                if (!treeName[0]) {
                        fprintf(stderr,"failed: You must specify a server or a tree\n");
                        goto bailout;
                }


                  if ((dserr=NWCXAttachToTreeByName (&conn,treeName))) {
                         fprintf(stderr,"failed:Cannot attach to tree %s.err:%s\n",
                                      treeName,strnwerror(dserr));
                        goto bailout;

                }


        }
        if (!conn) {
		fprintf(stderr, "ncp_open failed with %s\n",strnwerror(err));
		goto bailout;
	}
	dserr = NWDSAddConnection(ctx, conn);
#endif
	if (dserr) {
		fprintf(stderr, "failed:Cannot bind connection to context: %s\n",
			strnwerror(dserr));
                goto bailout;
	}

/****WILL  fail if not using a permanent/shared connection
       so we prefer to check that parameter -o has been specified (see above)
       if (!objectName) {
            objectName=malloc (256);
            dserr= NWDSWhoAmI(ctx,objectName);
            if (dserr) {
	                fprintf(stderr, "NWDSWhoAmi failed with error: %s\n",
               			strnwerror(dserr));
               goto bailout;
           }
        }
*********************************************************************/
        /*fprintf(stderr, "fetching  %s %s \n", objectName,attributeName);*/
        dserr=readAttributesValues(ctx,objectName,attributeName,sepvalue,sepattr);

bailout:
       	if (conn)
            NWCCCloseConn(conn);
	if (ctx)
           if ((dserr2=NWDSFreeContext(ctx))){
		fprintf(stderr, "NWDSFreeContext failed with %s\n", strnwerror(dserr2));
		return dserr2;
	   }

        }

	return dserr;

}