Ejemplo n.º 1
0
/**
 *Set the first name
 *
 *Input:
 *	info	is a pointer to person's info
 *	name	contains the first name
 *Return:
 *	0 to indicate failure
 *	1 to indicate success
 */
int setFirstName(PersonInfo *info, char *name)
{
	if (name == NULL ) // Check for empty string
		{
			printf("No first name detected !");
			return 0; 
		}
	else
		{
			int i = 0;
			
			while( name[i] != '\0' ) // Count for the total number of characters in the string until end of the string
				i++ ;
				
			if  ( i > 20 ) // Check if the name has more than 20 characters, it will return 0
				{
					printf("Insufficient space to allocate your lengthy first name.I'm sorry !");
					return 0;
				}
			
			int j = 0 ;
			for (j = 0 ; name[j] != '\0' ; ) //Loop throughout the string 
			{
						
				if ( isalpha(name[j]) != 0 ) // If the current character is an alphabet, isalpha will return a value not equal to 0
						j++;				 // and increment the counter to check for next character
				
				else if ( isblank(name[j]) != 0 ) // Check for space in first name , isblank return not zero when true
					{
						if ( j == 0 )	// To check for the starting character of the name cannot be blank or space 
						{	
							printf("You can't have your first name starting with a blank");
							return 0;
						}
							
						else 
							j++;
					}
					
				else if ( isdigit(name[j]) != 0 ) //Check for presence of digits, isdigit will also return non zero value if true
					{
						printf("You have number/numbers in your first name @[email protected] ???");
						return 0;
					}
					
				else //If all the above condition aren't true, it will be characters liek @,_|\ and more....
					{
						printf("Invalid character found in your first name!");
						return 0;
					}
					
					
					
			}
					
			printf("Hello %s ",name); // Just to print out the first name
			return 1;	// Pass all the test and return 1 for success
				
		}
		
	
}
Ejemplo n.º 2
0
/* 
 * this must be thread safe . no global, no static.
 *           return value  next symbol : success
 *                              S_NULL : end
 *                             S_ERROR : error
 *  forereading is not necessary , so do not do it.
 */
static int get_sym(struct c_desc *cd)
{
    char *p;
    int len;
    int val;
  
    /* skip white space */
    while(*cd->cur_p == ' ') cd->cur_p++;
  
    if(*cd->cur_p == '$') { /* $Foobar */
	p = cd->cur_p + 1;
	while(isalpha(*p)) p++;
	len = p - cd->cur_p - 1;
    
	if(cd->id_len < len + 1) {
	    cd->id = (char *)xrealloc(cd->id,len + 1);
	    cd->id_len = len + 1;
	}
	memcpy(cd->id,cd->cur_p + 1,len);
	cd->id[len] = '\0';
	cd->cur_p = p;
	cd->op = S_ID;
    }
    else if(isdigit(*cd->cur_p)) {
	val = 0;
	while(isdigit(*cd->cur_p)) { /* always decimal */
	    val *= 10;
	    val += *cd->cur_p - '0';
	    cd->cur_p++;
	}
	cd->op = S_NUM;
	cd->val = val;
    }
    else if(*cd->cur_p == '<') {
	cd->cur_p++;
	if(*cd->cur_p == '=') {
	    cd->cur_p++;
	    cd->op = S_LESSEQ;
	}
	else {
	    cd->op = S_LESS;
	}
    }
    else if(*cd->cur_p == '>') {
	cd->cur_p++;
	if(*cd->cur_p == '=') {
	    cd->cur_p++;
	    cd->op = S_MOREEQ;
	}
	else {
	    cd->op = S_MORE;
	}
    }
    else if(*cd->cur_p == '&') {
	cd->cur_p++;
	if(*cd->cur_p == '&') {
	    cd->cur_p++;
	    cd->op = S_AND;
	}
	else {
	    cd->op = S_ERROR;   /* & operator is not supported */
	}
    }
    else if(*cd->cur_p == '|') {
	cd->cur_p++;
	if(*cd->cur_p == '|') {
	    cd->cur_p++;
	    cd->op = S_OR;
	}
	else {
	    cd->op = S_ERROR;   /* | operator is not supported */
	}
    }
    else if(*cd->cur_p == '=') {
	cd->cur_p++;
	if(*cd->cur_p == '=') {
	    cd->cur_p++;
	    cd->op = S_EQ;
	}
	else {
	    cd->op = S_SUBSTI;
	}
    }
    else if(*cd->cur_p == '(') {
	cd->cur_p++;
	cd->op = S_LPAREN;
    }
    else if(*cd->cur_p == ')') {
	cd->cur_p++;
	cd->op = S_RPAREN;
    }
    else if(*cd->cur_p == ',' || *cd->cur_p == ';') { /*end of condition ',' */
	cd->op = S_NULL; /*END*/
    }
    else {
	display(MSDL_ERR,"asmrule: syntax error\n");
	cd->op = S_ERROR;
    }
  
    return cd->op;
}
Ejemplo n.º 3
0
static int32_t
gettoken(struct snmp_toolinfo *snmptoolctx)
{
	int c;
	struct enum_type *t;

	if (saved_token != -1) {
		c = saved_token;
		saved_token = -1;
		return (c);
	}

  again:
	/*
	 * Skip any whitespace before the next token.
	 */
	while ((c = tgetc()) != EOF) {
		if (c == '\n')
			input->lno++;
		if (!isspace(c))
			break;
	}
	if (c == EOF)
		return (TOK_EOF);

	if (!isascii(c)) {
		warnx("unexpected character %#2x", (u_int) c);
		return (TOK_ERR);
	}

	/*
	 * Skip comments.
	 */
	if (c == '#') {
		while ((c = tgetc()) != EOF) {
			if (c == '\n') {
				input->lno++;
				goto again;
			}
		}
		warnx("unexpected EOF in comment");
		return (TOK_ERR);
	}

	/*
	 * Single character tokens.
	 */
	if (strchr("():|", c) != NULL)
		return (c);

	if (c == '"' || c == '<') {
		int32_t end = c;
		size_t n = 0;

		val = 1;
		if (c == '<') {
			val = 0;
			end = '>';
		}

		while ((c = tgetc()) != EOF) {
			if (c == end)
				break;
			if (n == sizeof(nexttok) - 1) {
				nexttok[n++] = '\0';
				warnx("filename too long '%s...'", nexttok);
				return (TOK_ERR);
			}
			nexttok[n++] = c;
		}
		nexttok[n++] = '\0';
		return (TOK_FILENAME);
	}

	/*
	 * Sort out numbers.
	 */
	if (isdigit(c)) {
		size_t n = 0;
		nexttok[n++] = c;
		while ((c = tgetc()) != EOF) {
			if (!isdigit(c)) {
				if (tungetc(c) < 0)
					return (TOK_ERR);
				break;
			}
			if (n == sizeof(nexttok) - 1) {
				nexttok[n++] = '\0';
				warnx("number too long '%s...'", nexttok);
				return (TOK_ERR);
			}
			nexttok[n++] = c;
		}
		nexttok[n++] = '\0';
		sscanf(nexttok, "%lu", &val);
		return (TOK_NUM);
	}

	/*
	 * So that has to be a string.
	 */
	if (isalpha(c) || c == '_' || c == '-') {
		size_t n = 0;
		nexttok[n++] = c;
		while ((c = tgetc()) != EOF) {
			if (!isalnum(c) && c != '_' && c != '-') {
				if (tungetc (c) < 0)
					return (TOK_ERR);
				break;
			}
			if (n == sizeof(nexttok) - 1) {
				nexttok[n++] = '\0';
				warnx("string too long '%s...'", nexttok);
				return (TOK_ERR);
			}
			nexttok[n++] = c;
		}
		nexttok[n++] = '\0';

		/*
		 * Keywords.
		 */
		for (c = 0; keywords[c].str != NULL; c++)
			if (strcmp(keywords[c].str, nexttok) == 0) {
				val = keywords[c].val;
				return (keywords[c].tok);
			}

		if ((t = snmp_enumtc_lookup(snmptoolctx, nexttok)) != NULL) {
			val = t->syntax;
			return (TOK_DEFTYPE);
		}

		return (TOK_STR);
	}

	if (isprint(c))
		warnx("%u: unexpected character '%c'", input->lno, c);
	else
		warnx("%u: unexpected character 0x%02x", input->lno, (u_int) c);

	return (TOK_ERR);
}
Ejemplo n.º 4
0
static char *get_protocol_scheme(char const **s, unsigned int *err_out) {

    *err_out = UPARSE_ERROR;

    if (NULL == *s) {
        fprintf(stderr,"input s is null\n");
        return NULL;
    }

    // Local copy we can advance.
    char const *c = *s;

    // Choose a sensible limit for a scheme.
    size_t const max_scheme_len = 16;
    char scheme[max_scheme_len+1];
    memset(&scheme[0], 0, sizeof(scheme));

    size_t j = 0;

    bool seen_prefix = false;

    // Copy alpha characters preceeding the ':'
    while (*c) {
        if (SCHEME_DELIM_PREFIX == c[0]) {
            seen_prefix = true;
            // Advance past SCHEME_DELIM_PREFIX, c should be pointing at a SCHEME_SLASH now.
            c++;
            break;
        } else if (!isalpha(*c)) {
            fprintf(stderr,"'%c' is invalid\n",*c);
            return NULL;
        } else if (max_scheme_len == j) {
            fprintf(stderr,"scheme exceeds max scheme len %lu\n",max_scheme_len);
            return NULL;
        } else {
            scheme[j] = c[0];
        }
        c++;
        j++;
    }

    if (!seen_prefix) {
        fprintf(stderr,"no scheme delimiter prefix '%c' found\n",SCHEME_DELIM_PREFIX);
        return NULL;
    }

    // No scheme was found.
    if (0 == j) {
        fprintf(stderr,"no scheme was found\n");
        return NULL;
    }

    // Look for the slashes after SCHEME_DELIM_PREFIX.
    bool seen_slash = false;
    while (*c) {
        if (SCHEME_SLASH == c[0]) {
            seen_slash = true;
            c++;
        } else {
            break;
        }
    }

    if (!seen_slash) {
        fprintf(stderr,"no scheme slash '%c' found\n",SCHEME_SLASH);
        return NULL;
    }

    // Advance pointer past all of the scheme chars and delims.
    *s = c;

    scheme[j] = '\0';
    *err_out = NO_UPARSE_ERROR;
    return strdup(scheme);
}
Ejemplo n.º 5
0
token_t akl_lex(struct akl_io_device *dev)
{
    int ch;
    /* We should take care of the '+', '++',
      and etc. style functions. Moreover the
      positive and negative numbers must also work:
      '(++ +5)' should be valid. */
    char op = 0;
    if (!buffer)
        init_buffer();

    assert(dev);
    while ((ch = akl_io_getc(dev))) {
        /* We should avoid the interpretation of the Unix shebang */
        if (dev->iod_char_count == 1 && ch == '#') {
            while ((ch = akl_io_getc(dev)) && ch != '\n') 
                ;
        }
        if (ch == EOF) {
           return tEOF;
        } else if (ch == '\n') {
           dev->iod_line_count++;
           dev->iod_char_count = 0;
        } else if (ch == '+' || ch == '-') {
            if (op != 0) {
                if (op == '+')
                    strcpy(buffer, "++");
                else
                    strcpy(buffer, "--");
                op = 0;
                return tATOM;
            }
            op = ch;
        } else if (isdigit(ch)) {
            akl_io_ungetc(ch, dev);
            copy_number(dev, op);
            op = 0;
            return tNUMBER;
        } else if (ch == ' ' || ch == '\n') {
            dev->iod_column = dev->iod_char_count+1;
            if (op != 0) {
                if (op == '+')
                    strcpy(buffer, "+");
                else
                    strcpy(buffer, "-");
                op = 0;
                return tATOM;
            } else {
                continue;
            }
        } else if (ch == '"') {
            ch = akl_io_getc(dev);
            if (ch == '"')
                return tNIL;
            akl_io_ungetc(ch, dev);
            copy_string(dev); 
            return tSTRING;
        } else if (ch == '(') {
            dev->iod_column = dev->iod_char_count+1;
            ch = akl_io_getc(dev);
            if (ch == ')')
                return tNIL;
            akl_io_ungetc(ch, dev);
            return tLBRACE;
        } else if (ch == ')') {
            return tRBRACE;
        } else if (ch == '\'' || ch == ':') {
            return tQUOTE;
        } else if (ch == ';') {
            while ((ch = akl_io_getc(dev)) != '\n') {
                if (akl_io_eof(dev))
                    return tEOF;
            }
        } else if (isalpha(ch) || ispunct(ch)) {
            akl_io_ungetc(ch, dev);
            copy_atom(dev);
            if ((strcasecmp(buffer, "NIL")) == 0)
                return tNIL;
            else if ((strcasecmp(buffer, "T")) == 0)
                return tTRUE;
            else
                return tATOM;
        } else {
            continue;
        }
    }
    return tEOF;
}
Ejemplo n.º 6
0
static void
opt(struct tbl_node *tbl, int ln, const char *p, int *pos)
{
	int		 i, sv;
	char		 buf[KEY_MAXNAME];

	/*
	 * Parse individual options from the stream as surrounded by
	 * this goto.  Each pass through the routine parses out a single
	 * option and registers it.  Option arguments are processed in
	 * the arg() function.
	 */

again:	/*
	 * EBNF describing this section:
	 *
	 * options	::= option_list [:space:]* [;][\n]
	 * option_list	::= option option_tail
	 * option_tail	::= [:space:]+ option_list |
	 * 		::= epsilon
	 * option	::= [:alpha:]+ args
	 * args		::= [:space:]* [(] [:alpha:]+ [)]
	 */

	while (isspace((unsigned char)p[*pos]))
		(*pos)++;

	/* Safe exit point. */

	if (';' == p[*pos])
		return;

	/* Copy up to first non-alpha character. */

	for (sv = *pos, i = 0; i < KEY_MAXNAME; i++, (*pos)++) {
		buf[i] = (char)tolower((unsigned char)p[*pos]);
		if ( ! isalpha((unsigned char)buf[i]))
			break;
	}

	/* Exit if buffer is empty (or overrun). */

	if (KEY_MAXNAME == i || 0 == i) {
		mandoc_msg(MANDOCERR_TBL, tbl->parse, ln, *pos, NULL);
		return;
	}

	buf[i] = '\0';

	while (isspace((unsigned char)p[*pos]))
		(*pos)++;

	/* 
	 * Look through all of the available keys to find one that
	 * matches the input.  FIXME: hashtable this.
	 */

	for (i = 0; i < KEY_MAXKEYS; i++) {
		if (strcmp(buf, keys[i].name))
			continue;

		/*
		 * Note: this is more difficult to recover from, as we
		 * can be anywhere in the option sequence and it's
		 * harder to jump to the next.  Meanwhile, just bail out
		 * of the sequence altogether.
		 */

		if (keys[i].key) 
			tbl->opts.opts |= keys[i].key;
		else if ( ! arg(tbl, ln, p, pos, keys[i].ident))
			return;

		break;
	}

	/* 
	 * Allow us to recover from bad options by continuing to another
	 * parse sequence.
	 */

	if (KEY_MAXKEYS == i)
		mandoc_msg(MANDOCERR_TBLOPT, tbl->parse, ln, sv, NULL);

	goto again;
	/* NOTREACHED */
}
Ejemplo n.º 7
0
char *TKGetNextToken( TokenizerT * tk )
{	// Begin TKGetNextToken

	/**
	 * Check that the string is not empty.
	 */

	if(tk->str == '\0')
	{	// Begin if-statement
		return '\0';
	}	// End if-statement

	/*
	 * calloc(tk->strSize-tk->curChar, sizeof(char));
	 * This will assign for the first token the amount of space
	 * required to contain the entire string in the case that the first token
	 * the whole input is one token. The next time the function is used it will
	 * allocate the size of the string minus the amount of characters already
	 * surpassed.
	 */
	char *arr = calloc(tk->strSize-tk->curChar, sizeof(char));

	int i = 0; // Current index in arr[i]

	while ((char)tk->str[tk->curChar] != '\0')
	{	// Begin while-loop

		/**
		 * This if-statement will check if tk->str[tk->curChar] is
		 * a whitespace character. If a whitespace character is found
		 * the current character which contains the whitespace
		 * will be incremented over (e.g. tk->curChar++) so that the
		 * next time the method is called it will start after the
		 * whitespace character.
		 */
		if((char)tk->str[tk->curChar] == ' ')
		{	// Begin if-statement
			tk->curChar++;
			if((char)tk->str[tk->curChar] == '\0')
			{
				arr[i] = ' ';
				break;
			}
		}	// End if-statement
		else if(isalpha(tk->str[tk->curChar]))
		{	// Begin if-statement
			arr[i] = tk->str[tk->curChar];	// Store current str[index] in arr[i]
			i++;
			tk->curChar++;

			/**
			 * Continue tokenizing word while next character is an alphanumeric
			 * character.
			 */
			while(isalnum(tk->str[tk->curChar]) && (char)tk->str[tk->curChar] != '\0')
			{	// Begin while loop
				arr[i] = tk->str[tk->curChar];
				i++;
				tk->curChar++;
			}	//
			tk->tokenDesc[tk->manyTokens] = "word";
			break;
		}
		else if(isdigit(tk->str[tk->curChar]))
		{
			arr[i] = tk->str[tk->curChar];
			i++;
			tk->curChar++;
			while(isdigit(tk->str[tk->curChar]) && (char)tk->str[tk->curChar] != '\0')
			{
				arr[i] = tk->str[tk->curChar];
				i++;
				tk->curChar++;
			}
			if((char)tk->str[tk->curChar] == 'L')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "long decimal number";
				tk->curChar++;
				break;
			}
			else if((char)tk->str[tk->curChar] == '.')
			{
				tk->tokenDesc[tk->manyTokens] = "float";
				arr[i] = tk->str[tk->curChar];
				i++;
				tk->curChar++;
				while(isdigit(tk->str[tk->curChar]))
				{
					arr[i] = tk->str[tk->curChar];
					i++;
					tk->curChar++;
					if((char)tk->str[tk->curChar] == 'e')
					{
						arr[i] = tk->str[tk->curChar];
						i++;
						tk->curChar++;
						if((char)tk->str[tk->curChar] == '-' || (char)tk->str[tk->curChar] == '+')
						{
							arr[i] = tk->str[tk->curChar];
							i++;
							tk->curChar++;
							if(!isdigit(tk->str[tk->curChar]))
							{
								tk->tokenDesc[tk->manyTokens] = "improper float";
								break;
							}
							while(isdigit(tk->str[tk->curChar]))
							{
								arr[i] = tk->str[tk->curChar];
								i++;
								tk->curChar++;
							}
							tk->tokenDesc[tk->manyTokens] = "scientific float";
							break;
						}
						else
						{
							tk->tokenDesc[tk->manyTokens] = "improper float";
							break;
						}
					}
				}
				break;
			}
			tk->tokenDesc[tk->manyTokens] = "decimal number";
			tk->curChar++;
			break;
		}
		else if((char)tk->str[tk->curChar] == '[')
		{
			arr[i] = tk->str[tk->curChar];
			tk->tokenDesc[tk->manyTokens] = "left brace";
			tk->curChar++;
			break;
		}
		else if((char)tk->str[tk->curChar] == ']')
		{
			arr[i] = tk->str[tk->curChar];
			tk->tokenDesc[tk->manyTokens] = "right brace";
			tk->curChar++;
			break;
		}
		else if((char)tk->str[tk->curChar] == '(')
		{
			arr[i] = tk->str[tk->curChar];
			tk->tokenDesc[tk->manyTokens] = "left parentheses";
			tk->curChar++;
			break;
		}
		else if((char)tk->str[tk->curChar] == ')')
		{
			arr[i] = tk->str[tk->curChar];
			tk->tokenDesc[tk->manyTokens] = "right parentheses";
			tk->curChar++;
			break;
		}
		else if((char)tk->str[tk->curChar] == '+')
		{
			arr[i] = tk->str[tk->curChar];
			i++;
			tk->tokenDesc[tk->manyTokens] = "plus";
			tk->curChar++;
			if((char)tk->str[tk->curChar] == '=')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "plusequals";
				tk->curChar++;
			}
			else if((char)tk->str[tk->curChar] == '+')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "increment";
				tk->curChar++;
			}
			break;
		}
		else if((char)tk->str[tk->curChar] == '-')
		{
			arr[i] = tk->str[tk->curChar];
			i++;
			tk->tokenDesc[tk->manyTokens] = "minus";
			tk->curChar++;
			if((char)tk->str[tk->curChar] == '=')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "minusequals";
				tk->curChar++;
			}
			else if((char)tk->str[tk->curChar] == '-')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "decrement";
				tk->curChar++;
			}
			break;
		}
		else if((char)tk->str[tk->curChar] == '\%')
		{
			arr[i] = tk->str[tk->curChar];
			i++;
			tk->curChar++;

			if((char)tk->str[tk->curChar] == 'd')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "signed decimal integer conversion character";
			}
			else if((char)tk->str[tk->curChar] == 'u')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "unsigned decimal integer conversion character (used in printf only)";
			}
			else if((char)tk->str[tk->curChar] == 'x')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "unsigned hexidecimal integer conversion character";
			}
			else if((char)tk->str[tk->curChar] == 'h')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "unsigned short integer conversion character (used in scanf only)";
			}
			else if((char)tk->str[tk->curChar] == 'o')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "unsigned octal integer conversion character";
			}
			else if((char)tk->str[tk->curChar] == 'c')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "single character conversion character";
			}
			else if((char)tk->str[tk->curChar] == 's')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "null terminated string conversion character";
			}
			else if((char)tk->str[tk->curChar] == 'f')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "fixed point notation for float or double conversion character";
			}
			else if((char)tk->str[tk->curChar] == 'e')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "scientific notation for float or double conversion character (printf only)";
			}
			else if((char)tk->str[tk->curChar] == 'g')
			{
				arr[i] = tk->str[tk->curChar];
				tk->tokenDesc[tk->manyTokens] = "use %e or %f, whichever is shorter conversion character (printf only)";
			}
			tk->curChar++;
			break;
		}
	}	// End while-loop
	return arr;
}	// End TKGetNextToken
Ejemplo n.º 8
0
int isalnum( int c )
{
        return isalpha( c ) | isdigit( c );
}
Ejemplo n.º 9
0
static int32_t
valid_typing (char c)
{
    /* Valid typing include letters, numbers, space, and backspace/delete. */
    return (isalpha (c) || isdigit (c) || ' ' == c || 8 == c || 127 == c);
}
Ejemplo n.º 10
0
static PRBool
IsRootDirectory(char *fn, size_t buflen)
{
    char *p;
    PRBool slashAdded = PR_FALSE;
    PRBool rv = PR_FALSE;

    if (_PR_IS_SLASH(fn[0]) && fn[1] == '\0') {
        return PR_TRUE;
    }

    if (isalpha(fn[0]) && fn[1] == ':' && _PR_IS_SLASH(fn[2])
            && fn[3] == '\0') {
        rv = GetDriveType(fn) > 1 ? PR_TRUE : PR_FALSE;
        return rv;
    }

    /* The UNC root directory */

    if (_PR_IS_SLASH(fn[0]) && _PR_IS_SLASH(fn[1])) {
        /* The 'server' part should have at least one character. */
        p = &fn[2];
        if (*p == '\0' || _PR_IS_SLASH(*p)) {
            return PR_FALSE;
        }

        /* look for the next slash */
        do {
            p++;
        } while (*p != '\0' && !_PR_IS_SLASH(*p));
        if (*p == '\0') {
            return PR_FALSE;
        }

        /* The 'share' part should have at least one character. */
        p++;
        if (*p == '\0' || _PR_IS_SLASH(*p)) {
            return PR_FALSE;
        }

        /* look for the final slash */
        do {
            p++;
        } while (*p != '\0' && !_PR_IS_SLASH(*p));
        if (_PR_IS_SLASH(*p) && p[1] != '\0') {
            return PR_FALSE;
        }
        if (*p == '\0') {
            /*
             * GetDriveType() doesn't work correctly if the
             * path is of the form \\server\share, so we add
             * a final slash temporarily.
             */
            if ((p + 1) < (fn + buflen)) {
                *p++ = '\\';
                *p = '\0';
                slashAdded = PR_TRUE;
            } else {
                return PR_FALSE; /* name too long */
            }
        }
        rv = GetDriveType(fn) > 1 ? PR_TRUE : PR_FALSE;
        /* restore the 'fn' buffer */
        if (slashAdded) {
            *--p = '\0';
        }
    }
    return rv;
}