Subversion Repositories HelenOS

Rev

Rev 3480 | Rev 3483 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
  2.  * Copyright (C) 1998 by Wes Peters <wes@softweyr.com>
  3.  * Copyright (c) 1988, 1993 The Regents of the University of California.
  4.  * All rights reserved by all copyright holders.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions are met:
  8.  *
  9.  * Redistributions of source code must retain the above copyright notice, this
  10.  * list of conditions and the following disclaimer.
  11.  *
  12.  * Redistributions in binary form must reproduce the above copyright notice,
  13.  * this list of conditions and the following disclaimer in the documentation
  14.  * and/or other materials provided with the distribution.
  15.  *
  16.  * Neither the name of the original program's authors nor the names of its
  17.  * contributors may be used to endorse or promote products derived from this
  18.  * software without specific prior written permission.
  19.  *
  20.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23.  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30.  * POSSIBILITY OF SUCH DAMAGE.
  31.  */
  32.  
  33. /* NOTES:
  34.  * 1 - Various functions were adapted from FreeBSD (copyright holders noted above)
  35.  *     these functions are identified with comments.
  36.  *
  37.  * 2 - Some of these have since appeared in libc. They remain here for various
  38.  *     reasons, such as the eventual integration of garbage collection for things
  39.  *     that allocate memory and don't automatically free it.
  40.  *
  41.  * 3 - Things that expect a pointer to an allocated string do _no_ sanity checking
  42.  *     if developing on a simulator with no debugger, take care :)
  43.  */
  44.  
  45. #include <stdio.h>
  46. #include <string.h>
  47. #include <stdarg.h>
  48. #include <stdlib.h>
  49. #include <stdarg.h>
  50.  
  51. #include "config.h"
  52. #include "errors.h"
  53. #include "util.h"
  54.  
  55. extern volatile int cli_errno;
  56.  
  57. /* some platforms do not have strdup, implement it here.
  58.  * Returns a pointer to an allocated string or NULL on failure */
  59. char * cli_strdup(const char *s1)
  60. {
  61.     size_t len = strlen(s1) + 1;
  62.     void *ret = malloc(len);
  63.  
  64.     if (ret == NULL) {
  65.         cli_errno = CL_ENOMEM;
  66.         return (char *) NULL;
  67.     }
  68.  
  69.     cli_errno = CL_EOK;
  70.     return (char *) memcpy(ret, s1, len);
  71. }
  72.  
  73. /*
  74.  * Take a previously allocated string (s1), re-size it to accept s2 and copy
  75.  * the contents of s2 into s1.
  76.  * Return -1 on failure, or the length of the copied string on success.
  77.  */
  78. size_t cli_redup(char **s1, const char *s2)
  79. {
  80.     size_t len;
  81.  
  82.     if (s2 == NULL)
  83.         return -1;
  84.  
  85.     len = strlen(s2) + 1;
  86.  
  87.     *s1 = realloc(*s1, len);
  88.  
  89.     if (*s1 == NULL) {
  90.         cli_errno = CL_ENOMEM;
  91.         return -1;
  92.     }
  93.  
  94.     *s1[len] = '\0';
  95.  
  96.     memcpy(*s1, s2, len);
  97.     cli_errno = CL_EOK;
  98.  
  99.     return len;
  100. }
  101.  
  102. /* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
  103. char * cli_strtok_r(char *s, const char *delim, char **last)
  104. {
  105.     char *spanp, *tok;
  106.     int c, sc;
  107.  
  108.     if (s == NULL && (s = *last) == NULL) {
  109.         cli_errno = CL_EFAIL;
  110.         return (NULL);
  111.     }
  112.  
  113. cont:
  114.     c = *s++;
  115.     for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
  116.         if (c == sc)
  117.             goto cont;
  118.     }
  119.  
  120.     if (c == 0) {       /* no non-delimiter characters */
  121.         *last = NULL;
  122.         return (NULL);
  123.     }
  124.  
  125.     tok = s - 1;
  126.  
  127.     for (;;) {
  128.         c = *s++;
  129.         spanp = (char *)delim;
  130.         do {
  131.             if ((sc = *spanp++) == c) {
  132.                 if (c == 0)
  133.                     s = NULL;
  134.                 else
  135.                     s[-1] = '\0';
  136.                 *last = s;
  137.                 return (tok);
  138.             }
  139.         } while (sc != 0);
  140.     }
  141. }
  142.  
  143. /* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
  144. char * cli_strtok(char *s, const char *delim)
  145. {
  146.     static char *last;
  147.  
  148.     return (cli_strtok_r(s, delim, &last));
  149. }
  150.  
  151. /* Count and return the # of elements in an array */
  152. unsigned int cli_count_args(char **args)
  153. {
  154.     unsigned int i;
  155.  
  156.     for (i=0; args[i] != NULL; i++);
  157.     return i;
  158. }
  159.  
  160. /* (re)allocates memory to store the current working directory, gets
  161.  * and updates the current working directory, formats the prompt
  162.  * string */
  163. unsigned int cli_set_prompt(cliuser_t *usr)
  164. {
  165.     usr->prompt = (char *) realloc(usr->prompt, PATH_MAX);
  166.     if (NULL == usr->prompt) {
  167.         cli_error(CL_ENOMEM, "Can not allocate prompt");
  168.         cli_errno = CL_ENOMEM;
  169.         return 1;
  170.     }
  171.     memset(usr->prompt, 0, sizeof(usr->prompt));
  172.  
  173.     usr->cwd = (char *) realloc(usr->cwd, PATH_MAX);
  174.     if (NULL == usr->cwd) {
  175.         cli_error(CL_ENOMEM, "Can not allocate cwd");
  176.         cli_errno = CL_ENOMEM;
  177.         return 1;
  178.     }
  179.     memset(usr->cwd, 0, sizeof(usr->cwd));
  180.  
  181.     usr->cwd = getcwd(usr->cwd, PATH_MAX - 1);
  182.  
  183.     if (NULL == usr->cwd)
  184.         snprintf(usr->cwd, PATH_MAX, "(unknown)");
  185.  
  186.     asprintf(&usr->prompt, "%s # ", usr->cwd);
  187.  
  188.     return 0;
  189. }
  190.  
  191.  
  192.