xref: /illumos-gate/usr/src/lib/libsasl/lib/saslutil.c (revision e44e85a7)
1 /*
2  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 
6 /* saslutil.c
7  * Rob Siemborski
8  * Tim Martin
9  * $Id: saslutil.c,v 1.41 2003/03/19 18:25:28 rjs3 Exp $
10  */
11 /*
12  * Copyright (c) 1998-2003 Carnegie Mellon University.  All rights reserved.
13  *
14  * Redistribution and use in source and binary forms, with or without
15  * modification, are permitted provided that the following conditions
16  * are met:
17  *
18  * 1. Redistributions of source code must retain the above copyright
19  *    notice, this list of conditions and the following disclaimer.
20  *
21  * 2. Redistributions in binary form must reproduce the above copyright
22  *    notice, this list of conditions and the following disclaimer in
23  *    the documentation and/or other materials provided with the
24  *    distribution.
25  *
26  * 3. The name "Carnegie Mellon University" must not be used to
27  *    endorse or promote products derived from this software without
28  *    prior written permission. For permission or any other legal
29  *    details, please contact
30  *      Office of Technology Transfer
31  *      Carnegie Mellon University
32  *      5000 Forbes Avenue
33  *      Pittsburgh, PA  15213-3890
34  *      (412) 268-4387, fax: (412) 268-7395
35  *      tech-transfer@andrew.cmu.edu
36  *
37  * 4. Redistributions of any form whatsoever must retain the following
38  *    acknowledgment:
39  *    "This product includes software developed by Computing Services
40  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
41  *
42  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
43  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
44  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
45  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
46  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
47  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
48  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
49  */
50 
51 #include <config.h>
52 #include <stdio.h>
53 #include <stdlib.h>
54 #include <string.h>
55 #include <assert.h>
56 #include <ctype.h>
57 #include <sys/types.h>
58 #include <sys/stat.h>
59 #include <fcntl.h>
60 #include <errno.h>
61 #ifdef HAVE_UNISTD_H
62 #include <unistd.h>
63 #endif
64 #ifdef HAVE_TIME_H
65 #include <time.h>
66 #endif
67 #include "saslint.h"
68 #include <saslutil.h>
69 
70 /*  Contains:
71  *
72  * sasl_decode64
73  * sasl_encode64
74  * sasl_mkchal
75  * sasl_utf8verify
76  * sasl_randcreate
77  * sasl_randfree
78  * sasl_randseed
79  * sasl_rand
80  * sasl_churn
81 */
82 
83 #ifndef _SUN_SDK_
84 char *encode_table;
85 char *decode_table;
86 #endif /* !_SUN_SDK_ */
87 
88 #define RPOOL_SIZE 3
89 struct sasl_rand_s {
90     unsigned short pool[RPOOL_SIZE];
91     /* since the init time might be really bad let's make this lazy */
92     int initialized;
93 };
94 
95 #define CHAR64(c)  (((c) < 0 || (c) > 127) ? -1 : index_64[(c)])
96 
97 static char basis_64[] =
98    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????";
99 
100 static char index_64[128] = {
101     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
102     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
103     -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
104     52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1,-1,-1,-1,
105     -1, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
106     15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
107     -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
108     41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
109 };
110 
111 /* base64 encode
112  *  in      -- input data
113  *  inlen   -- input data length
114  *  out     -- output buffer (will be NUL terminated)
115  *  outmax  -- max size of output buffer
116  * result:
117  *  outlen  -- gets actual length of output buffer (optional)
118  *
119  * Returns SASL_OK on success, SASL_BUFOVER if result won't fit
120  */
121 
sasl_encode64(const char * _in,unsigned inlen,char * _out,unsigned outmax,unsigned * outlen)122 int sasl_encode64(const char *_in, unsigned inlen,
123 		  char *_out, unsigned outmax, unsigned *outlen)
124 {
125     const unsigned char *in = (const unsigned char *)_in;
126     unsigned char *out = (unsigned char *)_out;
127     unsigned char oval;
128 #ifndef _SUN_SDK_
129     char *blah;
130 #endif /* !_SUN_SDK_ */
131     unsigned olen;
132 
133     /* check params */
134 #ifdef _SUN_SDK_
135     if (((inlen >0) && (in == NULL)) || _out == NULL) return SASL_BADPARAM;
136 #else
137     if ((inlen >0) && (in == NULL)) return SASL_BADPARAM;
138 #endif /* _SUN_SDK_ */
139 
140     /* Will it fit? */
141     olen = (inlen + 2) / 3 * 4;
142     if (outlen)
143       *outlen = olen;
144     if (outmax <= olen)
145       return SASL_BUFOVER;
146 
147     /* Do the work... */
148 #ifndef _SUN_SDK_
149     blah=(char *) out;
150 #endif /* !_SUN_SDK_ */
151     while (inlen >= 3) {
152       /* user provided max buffer size; make sure we don't go over it */
153         *out++ = basis_64[in[0] >> 2];
154         *out++ = basis_64[((in[0] << 4) & 0x30) | (in[1] >> 4)];
155         *out++ = basis_64[((in[1] << 2) & 0x3c) | (in[2] >> 6)];
156         *out++ = basis_64[in[2] & 0x3f];
157         in += 3;
158         inlen -= 3;
159     }
160     if (inlen > 0) {
161       /* user provided max buffer size; make sure we don't go over it */
162         *out++ = basis_64[in[0] >> 2];
163         oval = (in[0] << 4) & 0x30;
164         if (inlen > 1) oval |= in[1] >> 4;
165         *out++ = basis_64[oval];
166         *out++ = (inlen < 2) ? '=' : basis_64[(in[1] << 2) & 0x3c];
167         *out++ = '=';
168     }
169 
170     *out = '\0';
171 
172     return SASL_OK;
173 }
174 
175 /* base64 decode
176  *  in     -- input data
177  *  inlen  -- length of input data
178  *  out    -- output data (may be same as in, must have enough space)
179  *  outmax  -- max size of output buffer
180  * result:
181  *  outlen -- actual output length
182  *
183  * returns:
184  * SASL_BADPROT on bad base64,
185  * SASL_BUFOVER if result won't fit,
186  * SASL_OK on success
187  */
188 
sasl_decode64(const char * in,unsigned inlen,char * out,unsigned outmax,unsigned * outlen)189 int sasl_decode64(const char *in, unsigned inlen,
190 		  char *out, unsigned outmax, unsigned *outlen)
191 {
192     unsigned len = 0,lup;
193     int c1, c2, c3, c4;
194 
195     /* check parameters */
196 #ifdef _SUN_SDK_
197     if (out==NULL || in == NULL) return SASL_FAIL;
198 #else
199     if (out==NULL) return SASL_FAIL;
200 #endif /* _SUN_SDK_ */
201 
202     /* xxx these necessary? */
203     if (in[0] == '+' && in[1] == ' ') in += 2;
204     if (*in == '\r') return SASL_FAIL;
205 
206     for (lup=0;lup<inlen/4;lup++)
207     {
208         c1 = in[0];
209         if (CHAR64(c1) == -1) return SASL_BADPROT;
210         c2 = in[1];
211         if (CHAR64(c2) == -1) return SASL_BADPROT;
212         c3 = in[2];
213         if (c3 != '=' && CHAR64(c3) == -1) return SASL_BADPROT;
214         c4 = in[3];
215         if (c4 != '=' && CHAR64(c4) == -1) return SASL_BADPROT;
216         in += 4;
217         *out++ = (CHAR64(c1) << 2) | (CHAR64(c2) >> 4);
218         if(++len >= outmax) return SASL_BUFOVER;
219         if (c3 != '=') {
220             *out++ = ((CHAR64(c2) << 4) & 0xf0) | (CHAR64(c3) >> 2);
221             if(++len >= outmax) return SASL_BUFOVER;
222             if (c4 != '=') {
223                 *out++ = ((CHAR64(c3) << 6) & 0xc0) | CHAR64(c4);
224                 if(++len >= outmax) return SASL_BUFOVER;
225             }
226         }
227     }
228 
229     *out=0; /* terminate string */
230 
231     if(outlen) *outlen=len;
232 
233     return SASL_OK;
234 }
235 
236 /* make a challenge string (NUL terminated)
237  *  buf      -- buffer for result
238  *  maxlen   -- max length of result
239  *  hostflag -- 0 = don't include hostname, 1 = include hostname
240  * returns final length or 0 if not enough space
241  */
242 
sasl_mkchal(sasl_conn_t * conn,char * buf,unsigned maxlen,unsigned hostflag)243 int sasl_mkchal(sasl_conn_t *conn,
244 		char *buf,
245 		unsigned maxlen,
246 		unsigned hostflag)
247 {
248 #ifndef _SUN_SDK_
249   sasl_rand_t *pool = NULL;
250 #endif /* !_SUN_SDK_ */
251   unsigned long randnum;
252 #ifndef _SUN_SDK_
253   int ret;
254 #endif /* !_SUN_SDK_ */
255   time_t now;
256   unsigned len;
257 #ifdef _SUN_SDK_
258   const sasl_utils_t *utils;
259 
260   if (conn->type == SASL_CONN_SERVER)
261     utils = ((sasl_server_conn_t *)conn)->sparams->utils;
262   else if (conn->type == SASL_CONN_CLIENT)
263     utils = ((sasl_client_conn_t *)conn)->cparams->utils;
264   else
265     return 0;
266 #endif /* _SUN_SDK_ */
267 
268   len = 4			/* <.>\0 */
269     + (2 * 20);			/* 2 numbers, 20 => max size of 64bit
270 				 * ulong in base 10 */
271   if (hostflag && conn->serverFQDN)
272     len += strlen(conn->serverFQDN) + 1 /* for the @ */;
273 
274   if (maxlen < len)
275     return 0;
276 
277 #ifdef _SUN_SDK_
278   utils->rand(utils->rpool, (char *)&randnum, sizeof (randnum));
279 #else
280   ret = sasl_randcreate(&pool);
281   if(ret != SASL_OK) return 0; /* xxx sasl return code? */
282 
283   sasl_rand(pool, (char *)&randnum, sizeof(randnum));
284   sasl_randfree(&pool);
285 #endif /* _SUN_SDK_ */
286 
287   time(&now);
288 
289   if (hostflag && conn->serverFQDN)
290     snprintf(buf,maxlen, "<%lu.%lu@%s>", randnum, now, conn->serverFQDN);
291   else
292     snprintf(buf,maxlen, "<%lu.%lu>", randnum, now);
293 
294   return strlen(buf);
295 }
296 
297   /* borrowed from larry. probably works :)
298    * probably is also in acap server somewhere
299    */
sasl_utf8verify(const char * str,unsigned len)300 int sasl_utf8verify(const char *str, unsigned len)
301 {
302   unsigned i;
303 #ifdef _SUN_SDK_
304   if (str == NULL)
305     return len == 0 ? SASL_OK : SASL_BADPARAM;
306   if (len == 0) len = strlen(str);
307 #endif /* _SUN_SDK_ */
308   for (i = 0; i < len; i++) {
309     /* how many octets? */
310     int seqlen = 0;
311     while (str[i] & (0x80 >> seqlen)) ++seqlen;
312 #ifdef _SUN_SDK_
313     if (seqlen == 0) {
314 	if (str[i] == '\0' || str[i] == '\n' || str[i] == '\r')
315 	   return SASL_BADPROT;
316 	continue; /* this is a valid US-ASCII char */
317     }
318 #else
319     if (seqlen == 0) continue; /* this is a valid US-ASCII char */
320 #endif /* _SUN_SDK_ */
321     if (seqlen == 1) return SASL_BADPROT; /* this shouldn't happen here */
322     if (seqlen > 6) return SASL_BADPROT; /* illegal */
323     while (--seqlen)
324 #ifdef _SUN_SDK_
325       if ((str[++i] & 0xC0) != 0x80)
326 	return SASL_BADPROT; /* needed an appropriate octet */
327 #else
328       if ((str[++i] & 0xC0) != 0xF0) return SASL_BADPROT; /* needed a 10 octet */
329 #endif /* _SUN_SDK_ */
330   }
331   return SASL_OK;
332 }
333 
334 /*
335  * To see why this is really bad see RFC 1750
336  *
337  * unfortunatly there currently is no way to make
338  * cryptographically secure pseudo random numbers
339  * without specialized hardware etc...
340  * thus, this is for nonce use only
341  */
getranddata(unsigned short ret[RPOOL_SIZE])342 void getranddata(unsigned short ret[RPOOL_SIZE])
343 {
344     long curtime;
345 
346     memset(ret, 0, RPOOL_SIZE*sizeof(unsigned short));
347 
348 #ifdef DEV_RANDOM
349     {
350 	int fd;
351 
352 	fd = open(DEV_RANDOM, O_RDONLY);
353 	if(fd != -1) {
354 	    unsigned char *buf = (unsigned char *)ret;
355 	    ssize_t bytesread = 0;
356 	    size_t bytesleft = RPOOL_SIZE*sizeof(unsigned short);
357 
358 	    do {
359 		bytesread = read(fd, buf, bytesleft);
360 		if(bytesread == -1 && errno == EINTR) continue;
361 		else if(bytesread <= 0) break;
362 		bytesleft -= bytesread;
363 		buf += bytesread;
364 	    } while(bytesleft != 0);
365 
366 	    close(fd);
367 	}
368     }
369 #endif
370 
371 #ifdef HAVE_GETPID
372     ret[0] ^= (unsigned short) getpid();
373 #endif
374 
375 #ifdef HAVE_GETTIMEOFDAY
376     {
377 	struct timeval tv;
378 
379 	/* xxx autoconf macro */
380 #ifdef _SVID_GETTOD
381 	if (!gettimeofday(&tv))
382 #else
383 	if (!gettimeofday(&tv, NULL))
384 #endif
385 	{
386 	    /* longs are guaranteed to be at least 32 bits; we need
387 	       16 bits in each short */
388 	    ret[0] ^= (unsigned short) (tv.tv_sec & 0xFFFF);
389 	    ret[1] ^= (unsigned short) (clock() & 0xFFFF);
390 	    ret[1] ^= (unsigned short) (tv.tv_usec >> 16);
391 	    ret[2] ^= (unsigned short) (tv.tv_usec & 0xFFFF);
392 	    return;
393 	}
394     }
395 #endif /* HAVE_GETTIMEOFDAY */
396 
397     /* if all else fails just use time() */
398     curtime = (long) time(NULL); /* better be at least 32 bits */
399 
400     ret[0] ^= (unsigned short) (curtime >> 16);
401     ret[1] ^= (unsigned short) (curtime & 0xFFFF);
402     ret[2] ^= (unsigned short) (clock() & 0xFFFF);
403 
404     return;
405 }
406 
sasl_randcreate(sasl_rand_t ** rpool)407 int sasl_randcreate(sasl_rand_t **rpool)
408 {
409 #ifdef _SUN_SDK_
410   (*rpool)=sasl_sun_ALLOC(sizeof(sasl_rand_t));
411 #else
412   (*rpool)=sasl_ALLOC(sizeof(sasl_rand_t));
413 #endif /* _SUN_SDK_ */
414   if ((*rpool) == NULL) return SASL_NOMEM;
415 
416   /* init is lazy */
417   (*rpool)->initialized = 0;
418 
419   return SASL_OK;
420 }
421 
sasl_randfree(sasl_rand_t ** rpool)422 void sasl_randfree(sasl_rand_t **rpool)
423 {
424 #ifdef _SUN_SDK_
425     sasl_sun_FREE(*rpool);
426 #else
427     sasl_FREE(*rpool);
428 #endif /* _SUN_SDK_ */
429 }
430 
sasl_randseed(sasl_rand_t * rpool,const char * seed,unsigned len)431 void sasl_randseed (sasl_rand_t *rpool, const char *seed, unsigned len)
432 {
433     /* is it acceptable to just use the 1st 3 char's given??? */
434     unsigned int lup;
435 
436     /* check params */
437     if (seed == NULL) return;
438     if (rpool == NULL) return;
439 
440     rpool->initialized = 1;
441 
442     if (len > sizeof(unsigned short)*RPOOL_SIZE)
443       len = sizeof(unsigned short)*RPOOL_SIZE;
444 
445     for (lup = 0; lup < len; lup += 2)
446 	rpool->pool[lup/2] = (seed[lup] << 8) + seed[lup + 1];
447 }
448 
randinit(sasl_rand_t * rpool)449 static void randinit(sasl_rand_t *rpool)
450 {
451     assert(rpool);
452 
453     if (!rpool->initialized) {
454 	getranddata(rpool->pool);
455 	rpool->initialized = 1;
456 #if !(defined(WIN32)||defined(macintosh))
457 #ifndef HAVE_JRAND48
458     {
459       /* xxx varies by platform */
460 	unsigned int *foo = (unsigned int *)rpool->pool;
461 	srandom(*foo);
462     }
463 #endif /* HAVE_JRAND48 */
464 #endif /* WIN32 */
465     }
466 
467 }
468 
sasl_rand(sasl_rand_t * rpool,char * buf,unsigned len)469 void sasl_rand (sasl_rand_t *rpool, char *buf, unsigned len)
470 {
471     unsigned int lup;
472     /* check params */
473     if (!rpool || !buf) return;
474 
475     /* init if necessary */
476     randinit(rpool);
477 
478 #if (defined(WIN32)||defined(macintosh))
479     for (lup=0;lup<len;lup++)
480 	buf[lup] = (char) (rand() >> 8);
481 #else /* WIN32 */
482 #ifdef HAVE_JRAND48
483     for (lup=0; lup<len; lup++)
484 	buf[lup] = (char) (jrand48(rpool->pool) >> 8);
485 #else
486     for (lup=0;lup<len;lup++)
487 	buf[lup] = (char) (random() >> 8);
488 #endif /* HAVE_JRAND48 */
489 #endif /* WIN32 */
490 }
491 
492 /* this function is just a bad idea all around, since we're not trying to
493    implement a true random number generator */
sasl_churn(sasl_rand_t * rpool,const char * data,unsigned len)494 void sasl_churn (sasl_rand_t *rpool, const char *data, unsigned len)
495 {
496     unsigned int lup;
497 
498     /* check params */
499     if (!rpool || !data) return;
500 
501     /* init if necessary */
502     randinit(rpool);
503 
504     for (lup=0; lup<len; lup++)
505 	rpool->pool[lup % RPOOL_SIZE] ^= data[lup];
506 }
507 
sasl_erasebuffer(char * buf,unsigned len)508 void sasl_erasebuffer(char *buf, unsigned len) {
509     memset(buf, 0, len);
510 }
511 
512 #ifndef _SUN_SDK_
513 #ifdef WIN32
514 /*****************************************************************************
515  *
516  *  MODULE NAME : GETOPT.C
517  *
518  *  COPYRIGHTS:
519  *             This module contains code made available by IBM
520  *             Corporation on an AS IS basis.  Any one receiving the
521  *             module is considered to be licensed under IBM copyrights
522  *             to use the IBM-provided source code in any way he or she
523  *             deems fit, including copying it, compiling it, modifying
524  *             it, and redistributing it, with or without
525  *             modifications.  No license under any IBM patents or
526  *             patent applications is to be implied from this copyright
527  *             license.
528  *
529  *             A user of the module should understand that IBM cannot
530  *             provide technical support for the module and will not be
531  *             responsible for any consequences of use of the program.
532  *
533  *             Any notices, including this one, are not to be removed
534  *             from the module without the prior written consent of
535  *             IBM.
536  *
537  *  AUTHOR:   Original author:
538  *                 G. R. Blair (BOBBLAIR at AUSVM1)
539  *                 Internet: bobblair@bobblair.austin.ibm.com
540  *
541  *            Extensively revised by:
542  *                 John Q. Walker II, Ph.D. (JOHHQ at RALVM6)
543  *                 Internet: johnq@ralvm6.vnet.ibm.com
544  *
545  *****************************************************************************/
546 
547 /******************************************************************************
548  * getopt()
549  *
550  * The getopt() function is a command line parser.  It returns the next
551  * option character in argv that matches an option character in opstring.
552  *
553  * The argv argument points to an array of argc+1 elements containing argc
554  * pointers to character strings followed by a null pointer.
555  *
556  * The opstring argument points to a string of option characters; if an
557  * option character is followed by a colon, the option is expected to have
558  * an argument that may or may not be separated from it by white space.
559  * The external variable optarg is set to point to the start of the option
560  * argument on return from getopt().
561  *
562  * The getopt() function places in optind the argv index of the next argument
563  * to be processed.  The system initializes the external variable optind to
564  * 1 before the first call to getopt().
565  *
566  * When all options have been processed (that is, up to the first nonoption
567  * argument), getopt() returns EOF.  The special option "--" may be used to
568  * delimit the end of the options; EOF will be returned, and "--" will be
569  * skipped.
570  *
571  * The getopt() function returns a question mark (?) when it encounters an
572  * option character not included in opstring.  This error message can be
573  * disabled by setting opterr to zero.  Otherwise, it returns the option
574  * character that was detected.
575  *
576  * If the special option "--" is detected, or all options have been
577  * processed, EOF is returned.
578  *
579  * Options are marked by either a minus sign (-) or a slash (/).
580  *
581  * No errors are defined.
582  *****************************************************************************/
583 
584 #include <string.h>                 /* for strchr() */
585 
586 /* static (global) variables that are specified as exported by getopt() */
587 __declspec(dllexport) char *optarg = NULL;    /* pointer to the start of the option argument  */
588 __declspec(dllexport) int   optind = 1;       /* number of the next argv[] to be evaluated    */
589 __declspec(dllexport) int   opterr = 1;       /* non-zero if a question mark should be returned */
590 
591 
592 /* handle possible future character set concerns by putting this in a macro */
593 #define _next_char(string)  (char)(*(string+1))
594 
getopt(int argc,char * argv[],char * opstring)595 int getopt(int argc, char *argv[], char *opstring)
596 {
597     static char *pIndexPosition = NULL; /* place inside current argv string */
598     char *pArgString = NULL;        /* where to start from next */
599     char *pOptString;               /* the string in our program */
600 
601 
602     if (pIndexPosition != NULL) {
603         /* we last left off inside an argv string */
604         if (*(++pIndexPosition)) {
605             /* there is more to come in the most recent argv */
606             pArgString = pIndexPosition;
607         }
608     }
609 
610     if (pArgString == NULL) {
611         /* we didn't leave off in the middle of an argv string */
612         if (optind >= argc) {
613             /* more command-line arguments than the argument count */
614             pIndexPosition = NULL;  /* not in the middle of anything */
615             return EOF;             /* used up all command-line arguments */
616         }
617 
618         /*---------------------------------------------------------------------
619          * If the next argv[] is not an option, there can be no more options.
620          *-------------------------------------------------------------------*/
621         pArgString = argv[optind++]; /* set this to the next argument ptr */
622 
623         if (('/' != *pArgString) && /* doesn't start with a slash or a dash? */
624             ('-' != *pArgString)) {
625             --optind;               /* point to current arg once we're done */
626             optarg = NULL;          /* no argument follows the option */
627             pIndexPosition = NULL;  /* not in the middle of anything */
628             return EOF;             /* used up all the command-line flags */
629         }
630 
631         /* check for special end-of-flags markers */
632         if ((strcmp(pArgString, "-") == 0) ||
633             (strcmp(pArgString, "--") == 0)) {
634             optarg = NULL;          /* no argument follows the option */
635             pIndexPosition = NULL;  /* not in the middle of anything */
636             return EOF;             /* encountered the special flag */
637         }
638 
639         pArgString++;               /* look past the / or - */
640     }
641 
642     if (':' == *pArgString) {       /* is it a colon? */
643         /*---------------------------------------------------------------------
644          * Rare case: if opterr is non-zero, return a question mark;
645          * otherwise, just return the colon we're on.
646          *-------------------------------------------------------------------*/
647         return (opterr ? (int)'?' : (int)':');
648     }
649     else if ((pOptString = strchr(opstring, *pArgString)) == 0) {
650         /*---------------------------------------------------------------------
651          * The letter on the command-line wasn't any good.
652          *-------------------------------------------------------------------*/
653         optarg = NULL;              /* no argument follows the option */
654         pIndexPosition = NULL;      /* not in the middle of anything */
655         return (opterr ? (int)'?' : (int)*pArgString);
656     }
657     else {
658         /*---------------------------------------------------------------------
659          * The letter on the command-line matches one we expect to see
660          *-------------------------------------------------------------------*/
661         if (':' == _next_char(pOptString)) { /* is the next letter a colon? */
662             /* It is a colon.  Look for an argument string. */
663             if ('\0' != _next_char(pArgString)) {  /* argument in this argv? */
664                 optarg = &pArgString[1];   /* Yes, it is */
665             }
666             else {
667                 /*-------------------------------------------------------------
668                  * The argument string must be in the next argv.
669                  * But, what if there is none (bad input from the user)?
670                  * In that case, return the letter, and optarg as NULL.
671                  *-----------------------------------------------------------*/
672                 if (optind < argc)
673                     optarg = argv[optind++];
674                 else {
675                     optarg = NULL;
676                     return (opterr ? (int)'?' : (int)*pArgString);
677                 }
678             }
679             pIndexPosition = NULL;  /* not in the middle of anything */
680         }
681         else {
682             /* it's not a colon, so just return the letter */
683             optarg = NULL;          /* no argument follows the option */
684             pIndexPosition = pArgString;    /* point to the letter we're on */
685         }
686         return (int)*pArgString;    /* return the letter that matched */
687     }
688 }
689 
690 #ifndef PASSWORD_MAX
691 #  define PASSWORD_MAX 255
692 #endif
693 
694 #include <conio.h>
695 char *
getpass(prompt)696 getpass(prompt)
697 const char *prompt;
698 {
699 	register char *p;
700 	register c;
701 	static char pbuf[PASSWORD_MAX];
702 
703 	fprintf(stderr, "%s", prompt); (void) fflush(stderr);
704 	for (p=pbuf; (c = _getch())!=13 && c!=EOF;) {
705 		if (p < &pbuf[sizeof(pbuf)-1])
706 			*p++ = c;
707 	}
708 	*p = '\0';
709 	fprintf(stderr, "\n"); (void) fflush(stderr);
710 	return(pbuf);
711 }
712 
713 
714 
715 #endif /* WIN32 */
716 #endif /* !_SUN_SDK_ */
717