LCOV - code coverage report
Current view: top level - source3/libsmb - libsmb_path.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 94 174 54.0 %
Date: 2024-02-28 12:06:22 Functions: 2 4 50.0 %

          Line data    Source code
       1             : /*
       2             :    Unix SMB/Netbios implementation.
       3             :    SMB client library implementation
       4             :    Copyright (C) Andrew Tridgell 1998
       5             :    Copyright (C) Richard Sharpe 2000, 2002
       6             :    Copyright (C) John Terpstra 2000
       7             :    Copyright (C) Tom Jansen (Ninja ISD) 2002
       8             :    Copyright (C) Derrell Lipman 2003-2008
       9             :    Copyright (C) Jeremy Allison 2007, 2008
      10             : 
      11             :    This program is free software; you can redistribute it and/or modify
      12             :    it under the terms of the GNU General Public License as published by
      13             :    the Free Software Foundation; either version 3 of the License, or
      14             :    (at your option) any later version.
      15             : 
      16             :    This program is distributed in the hope that it will be useful,
      17             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      18             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      19             :    GNU General Public License for more details.
      20             : 
      21             :    You should have received a copy of the GNU General Public License
      22             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      23             : */
      24             : 
      25             : #include "includes.h"
      26             : #include "libsmbclient.h"
      27             : #include "libsmb_internal.h"
      28             : 
      29             : 
      30             : /*
      31             :  * smbc_urldecode()
      32             :  * and urldecode_talloc() (internal fn.)
      33             :  *
      34             :  * Convert strings of %xx to their single character equivalent.  Each 'x' must
      35             :  * be a valid hexadecimal digit, or that % sequence is left undecoded.
      36             :  *
      37             :  * dest may, but need not be, the same pointer as src.
      38             :  *
      39             :  * Returns the number of % sequences which could not be converted due to lack
      40             :  * of two following hexadecimal digits.
      41             :  */
      42             : static int
      43        8195 : urldecode_talloc(TALLOC_CTX *ctx, char **pp_dest, const char *src)
      44             : {
      45        8195 :         int old_length = strlen(src);
      46        8195 :         int i = 0;
      47        8195 :         int err_count = 0;
      48        8195 :         size_t newlen = 1;
      49           0 :         char *p, *dest;
      50             : 
      51        8195 :         if (old_length == 0) {
      52         360 :                 return 0;
      53             :         }
      54             : 
      55        7835 :         *pp_dest = NULL;
      56      104282 :         for (i = 0; i < old_length; ) {
      57       96447 :                 unsigned char character = src[i++];
      58             : 
      59       96447 :                 if (character == '%') {
      60           0 :                         uint8_t v;
      61           0 :                         bool ok = hex_byte(&src[i], &v);
      62           0 :                         if (ok) {
      63           0 :                                 character = v;
      64           0 :                                 if (character == '\0') {
      65           0 :                                         break; /* Stop at %00 */
      66             :                                 }
      67           0 :                                 i += 2;
      68             :                         } else {
      69           0 :                                 err_count++;
      70             :                         }
      71             :                 }
      72       96447 :                 newlen++;
      73             :         }
      74             : 
      75        7835 :         dest = talloc_array(ctx, char, newlen);
      76        7835 :         if (!dest) {
      77           0 :                 return err_count;
      78             :         }
      79             : 
      80        7835 :         err_count = 0;
      81      104282 :         for (p = dest, i = 0; i < old_length; ) {
      82       96447 :                 unsigned char character = src[i++];
      83             : 
      84       96447 :                 if (character == '%') {
      85           0 :                         uint8_t v;
      86           0 :                         bool ok = hex_byte(&src[i], &v);
      87           0 :                         if (ok) {
      88           0 :                                 character = v;
      89           0 :                                 if (character == '\0') {
      90           0 :                                         break; /* Stop at %00 */
      91             :                                 }
      92           0 :                                 i += 2;
      93             :                         } else {
      94           0 :                                 err_count++;
      95             :                         }
      96             :                 }
      97       96447 :                 *p++ = character;
      98             :         }
      99             : 
     100        7835 :         *p = '\0';
     101        7835 :         *pp_dest = dest;
     102        7835 :         return err_count;
     103             : }
     104             : 
     105             : int
     106           0 : smbc_urldecode(char *dest,
     107             :                char *src,
     108             :                size_t max_dest_len)
     109             : {
     110           0 :         TALLOC_CTX *frame = talloc_stackframe();
     111           0 :         char *pdest;
     112           0 :         int ret = urldecode_talloc(frame, &pdest, src);
     113             : 
     114           0 :         if (pdest) {
     115           0 :                 strlcpy(dest, pdest, max_dest_len);
     116             :         }
     117           0 :         TALLOC_FREE(frame);
     118           0 :         return ret;
     119             : }
     120             : 
     121             : /*
     122             :  * smbc_urlencode()
     123             :  *
     124             :  * Convert any characters not specifically allowed in a URL into their %xx
     125             :  * equivalent.
     126             :  *
     127             :  * Returns the remaining buffer length.
     128             :  */
     129             : int
     130           0 : smbc_urlencode(char *dest,
     131             :                char *src,
     132             :                int max_dest_len)
     133             : {
     134           0 :         char hex[] = "0123456789ABCDEF";
     135             : 
     136           0 :         for (; *src != '\0' && max_dest_len >= 3; src++) {
     137             : 
     138           0 :                 if ((*src < '0' &&
     139           0 :                      *src != '-' &&
     140           0 :                      *src != '.') ||
     141           0 :                     (*src > '9' &&
     142           0 :                      *src < 'A') ||
     143           0 :                     (*src > 'Z' &&
     144           0 :                      *src < 'a' &&
     145           0 :                      *src != '_') ||
     146           0 :                     (*src > 'z')) {
     147           0 :                         *dest++ = '%';
     148           0 :                         *dest++ = hex[(*src >> 4) & 0x0f];
     149           0 :                         *dest++ = hex[*src & 0x0f];
     150           0 :                         max_dest_len -= 3;
     151             :                 } else {
     152           0 :                         *dest++ = *src;
     153           0 :                         max_dest_len--;
     154             :                 }
     155             :         }
     156             : 
     157           0 :         if (max_dest_len <= 0) {
     158             :                 /* Ensure we return -1 if no null termination. */
     159           0 :                 return -1;
     160             :         }
     161             : 
     162           0 :         *dest++ = '\0';
     163           0 :         max_dest_len--;
     164             : 
     165           0 :         return max_dest_len;
     166             : }
     167             : 
     168             : /*
     169             :  * Function to parse a path and turn it into components
     170             :  *
     171             :  * The general format of an SMB URI is explain in Christopher Hertel's CIFS
     172             :  * book, at http://ubiqx.org/cifs/Appendix-D.html.  We accept a subset of the
     173             :  * general format ("smb:" only; we do not look for "cifs:").
     174             :  *
     175             :  *
     176             :  * We accept:
     177             :  *  smb://[[[domain;]user[:password]@]server[:port][/share[/path[/file]]]]
     178             :  *                                                              [?options]
     179             :  *
     180             :  * Meaning of URLs:
     181             :  *
     182             :  * smb://           Show all workgroups.
     183             :  *
     184             :  *                  The method of locating the list of workgroups varies
     185             :  *                  depending upon the setting of the context variable
     186             :  *                  context->options.browse_max_lmb_count.  This value
     187             :  *                  determines the maximum number of local master browsers to
     188             :  *                  query for the list of workgroups.  In order to ensure that
     189             :  *                  a complete list of workgroups is obtained, all master
     190             :  *                  browsers must be queried, but if there are many
     191             :  *                  workgroups, the time spent querying can begin to add up.
     192             :  *                  For small networks (not many workgroups), it is suggested
     193             :  *                  that this variable be set to 0, indicating query all local
     194             :  *                  master browsers.  When the network has many workgroups, a
     195             :  *                  reasonable setting for this variable might be around 3.
     196             :  *
     197             :  * smb://name/      if name<1D> or name<1B> exists, list servers in
     198             :  *                  workgroup, else, if name<20> exists, list all shares
     199             :  *                  for server ...
     200             :  *
     201             :  * If "options" are provided, this function returns the entire option list as a
     202             :  * string, for later parsing by the caller.  Note that currently, no options
     203             :  * are supported.
     204             :  */
     205             : 
     206             : #define SMBC_PREFIX "smb:"
     207             : 
     208             : int
     209        1691 : SMBC_parse_path(TALLOC_CTX *ctx,
     210             :                 SMBCCTX *context,
     211             :                 const char *fname,
     212             :                 char **pp_workgroup,
     213             :                 char **pp_server,
     214             :                 uint16_t *p_port,
     215             :                 char **pp_share,
     216             :                 char **pp_path,
     217             :                 char **pp_user,
     218             :                 char **pp_password,
     219             :                 char **pp_options)
     220             : {
     221           0 :         char *s;
     222           0 :         const char *p;
     223           0 :         char *q, *r;
     224        1691 :         char *workgroup = NULL;
     225           0 :         int len;
     226             : 
     227             :         /* Ensure these returns are at least valid pointers. */
     228        1691 :         *pp_server = talloc_strdup(ctx, "");
     229        1691 :         *p_port = smbc_getPort(context);
     230        1691 :         *pp_share = talloc_strdup(ctx, "");
     231        1691 :         *pp_path = talloc_strdup(ctx, "");
     232        1691 :         *pp_user = talloc_strdup(ctx, "");
     233        1691 :         *pp_password = talloc_strdup(ctx, "");
     234             : 
     235        1691 :         if (!*pp_server || !*pp_share || !*pp_path ||
     236        1691 :             !*pp_user || !*pp_password) {
     237           0 :                 return -1;
     238             :         }
     239             : 
     240             :         /*
     241             :          * Assume we won't find an authentication domain to parse, so default
     242             :          * to the workgroup in the provided context.
     243             :          */
     244        1691 :         if (pp_workgroup != NULL) {
     245        1619 :                 *pp_workgroup =
     246        1619 :                         talloc_strdup(ctx, smbc_getWorkgroup(context));
     247             :         }
     248             : 
     249        1691 :         if (pp_options) {
     250         243 :                 *pp_options = talloc_strdup(ctx, "");
     251             :         }
     252        1691 :         s = talloc_strdup(ctx, fname);
     253             : 
     254             :         /* see if it has the right prefix */
     255        1691 :         len = strlen(SMBC_PREFIX);
     256        1691 :         if (strncmp(s,SMBC_PREFIX,len) || (s[len] != '/' && s[len] != 0)) {
     257          40 :                 return -1; /* What about no smb: ? */
     258             :         }
     259             : 
     260        1651 :         p = s + len;
     261             : 
     262             :         /* Watch the test below, we are testing to see if we should exit */
     263             : 
     264        1651 :         if (strncmp(p, "//", 2) && strncmp(p, "\\\\", 2)) {
     265           8 :                 DEBUG(1, ("Invalid path (does not begin with smb://)\n"));
     266           8 :                 return -1;
     267             :         }
     268             : 
     269        1643 :         p += 2;  /* Skip the double slash */
     270             : 
     271             :         /* See if any options were specified */
     272        1643 :         if ((q = strrchr(p, '?')) != NULL ) {
     273             :                 /* There are options.  Null terminate here and point to them */
     274           0 :                 *q++ = '\0';
     275             : 
     276           0 :                 DEBUG(4, ("Found options '%s'\n", q));
     277             : 
     278             :                 /* Copy the options */
     279           0 :                 if (pp_options && *pp_options != NULL) {
     280           0 :                         TALLOC_FREE(*pp_options);
     281           0 :                         *pp_options = talloc_strdup(ctx, q);
     282             :                 }
     283             :         }
     284             : 
     285        1643 :         if (*p == '\0') {
     286           4 :                 goto decoding;
     287             :         }
     288             : 
     289        1639 :         if (*p == '/') {
     290           4 :                 *pp_server = talloc_strndup(
     291             :                         ctx, smbc_getWorkgroup(context), 16);
     292           4 :                 if (!*pp_server) {
     293           0 :                         return -1;
     294             :                 }
     295           4 :                 return 0;
     296             :         }
     297             : 
     298             :         /*
     299             :          * ok, its for us. Now parse out the server, share etc.
     300             :          *
     301             :          * However, we want to parse out [[domain;]user[:password]@] if it
     302             :          * exists ...
     303             :          */
     304             : 
     305             :         /* check that '@' occurs before '/', if '/' exists at all */
     306        1635 :         q = strchr_m(p, '@');
     307        1635 :         r = strchr_m(p, '/');
     308        1635 :         if (q && (!r || q < r)) {
     309        1489 :                 char *userinfo = NULL;
     310           0 :                 const char *u;
     311             : 
     312        1489 :                 next_token_no_ltrim_talloc(ctx, &p, &userinfo, "@");
     313        1489 :                 if (!userinfo) {
     314           0 :                         return -1;
     315             :                 }
     316        1489 :                 u = userinfo;
     317             : 
     318        1489 :                 if (strchr_m(u, ';')) {
     319           8 :                         next_token_no_ltrim_talloc(ctx, &u, &workgroup, ";");
     320           8 :                         if (!workgroup) {
     321           0 :                                 return -1;
     322             :                         }
     323           8 :                         if (pp_workgroup) {
     324           4 :                                 *pp_workgroup = workgroup;
     325             :                         }
     326             :                 }
     327             : 
     328        1489 :                 if (strchr_m(u, ':')) {
     329        1485 :                         next_token_no_ltrim_talloc(ctx, &u, pp_user, ":");
     330        1485 :                         if (!*pp_user) {
     331           0 :                                 return -1;
     332             :                         }
     333        1485 :                         *pp_password = talloc_strdup(ctx, u);
     334        1485 :                         if (!*pp_password) {
     335           0 :                                 return -1;
     336             :                         }
     337             :                 } else {
     338           4 :                         *pp_user = talloc_strdup(ctx, u);
     339           4 :                         if (!*pp_user) {
     340           0 :                                 return -1;
     341             :                         }
     342             :                 }
     343             :         }
     344             : 
     345        1635 :         if (!next_token_talloc(ctx, &p, pp_server, "/")) {
     346           0 :                 return -1;
     347             :         }
     348             : 
     349             :         /*
     350             :          * Does *pp_server contain a ':' ? If so
     351             :          * this denotes the port.
     352             :          */
     353        1635 :         q = strchr_m(*pp_server, ':');
     354        1635 :         if (q != NULL) {
     355           0 :                 long int port;
     356           0 :                 char *endptr = NULL;
     357           0 :                 *q = '\0';
     358           0 :                 q++;
     359           0 :                 if (*q == '\0') {
     360             :                         /* Bad port. */
     361           0 :                         return -1;
     362             :                 }
     363           0 :                 port = strtol(q, &endptr, 10);
     364           0 :                 if (*endptr != '\0') {
     365             :                         /* Bad port. */
     366           0 :                         return -1;
     367             :                 }
     368           0 :                 *p_port = (uint16_t)port;
     369             :         }
     370             : 
     371        1635 :         if (*p == (char)0) {
     372          12 :                 goto decoding;  /* That's it ... */
     373             :         }
     374             : 
     375        1623 :         if (!next_token_talloc(ctx, &p, pp_share, "/")) {
     376           0 :                 return -1;
     377             :         }
     378             : 
     379             :         /*
     380             :          * Prepend a leading slash if there's a file path, as required by
     381             :          * NetApp filers.
     382             :          */
     383        1623 :         if (*p != '\0') {
     384        1603 :                 *pp_path = talloc_asprintf(ctx,
     385             :                                            "\\%s",
     386             :                                            p);
     387             :         } else {
     388          20 :                 *pp_path = talloc_strdup(ctx, "");
     389             :         }
     390        1623 :         if (!*pp_path) {
     391           0 :                 return -1;
     392             :         }
     393        1623 :         string_replace(*pp_path, '/', '\\');
     394             : 
     395        1639 : decoding:
     396        1639 :         (void) urldecode_talloc(ctx, pp_path, *pp_path);
     397        1639 :         (void) urldecode_talloc(ctx, pp_server, *pp_server);
     398        1639 :         (void) urldecode_talloc(ctx, pp_share, *pp_share);
     399        1639 :         (void) urldecode_talloc(ctx, pp_user, *pp_user);
     400        1639 :         (void) urldecode_talloc(ctx, pp_password, *pp_password);
     401             : 
     402        1639 :         if (!workgroup) {
     403        1631 :                 workgroup = talloc_strdup(ctx, smbc_getWorkgroup(context));
     404             :         }
     405        1639 :         if (!workgroup) {
     406           0 :                 return -1;
     407             :         }
     408             : 
     409             :         /* set the credentials to make DFS work */
     410        1639 :         smbc_set_credentials_with_fallback(context,
     411             :                                            workgroup,
     412             :                                            *pp_user,
     413             :                                            *pp_password);
     414        1639 :         return 0;
     415             : }
     416             : 

Generated by: LCOV version 1.14