LCOV - code coverage report
Current view: top level - sql/server - rel_remote.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 44 57 77.2 %
Date: 2021-10-13 02:24:04 Functions: 4 5 80.0 %

          Line data    Source code
       1             : /*
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       5             :  *
       6             :  * Copyright 1997 - July 2008 CWI, August 2008 - 2021 MonetDB B.V.
       7             :  */
       8             : 
       9             : #include "monetdb_config.h"
      10             : #include "rel_remote.h"
      11             : 
      12             : #define mapi_prefix "mapi:monetdb://"
      13             : 
      14             : int
      15          52 : mapiuri_valid( const char *uri)
      16             : {
      17             :         int i = 0, l = 0;
      18             :         const char *p = uri;
      19             : 
      20          52 :         if (strncmp(p, mapi_prefix, strlen(mapi_prefix)))
      21             :                 return 0;
      22             :         /* optional host (todo limit to valid hostnames ??) */
      23          52 :         p += strlen(mapi_prefix);
      24          52 :         if (*p == '[') { //check for IPv6 addresses
      25           0 :                 for (; *p; p++) {
      26           0 :                         if (*p == ']')
      27             :                                 break;
      28             :                 }
      29             :         }
      30          52 :         if (!p)
      31             :                 return 0;
      32         526 :         for (; *p; p++) {
      33         526 :                 if (*p == ':' || *p == '/')
      34             :                         break;
      35             :         }
      36             :         if (!p)
      37             :                 return 0;
      38          52 :         if (*p == ':') {
      39             :                 char *x;
      40          52 :                 int i = strtol(p+1, &x, 10);
      41             : 
      42          52 :                 if (!x || i < 0 || i >= 64*1024)
      43           0 :                         return 0;
      44             :                 p = x;
      45             :         }
      46          52 :         if (*p != '/')
      47             :                 return 0;
      48          52 :         p++;
      49             :         /* now find at most 2 '/'s, with some string inbetween */
      50         763 :         for(; *p; p++, l++) {
      51         711 :                 if (*p == '/') {
      52          38 :                         if (l == 0) /* no string inbetween */
      53             :                                 return 0;
      54          38 :                         if (i == 2) /* 3 parts (ie database/schema/table) */
      55             :                                 return 0;
      56          38 :                         i++;
      57             :                         l=0;
      58             :                 }
      59             :         }
      60          52 :         if (i == 0 && l == 0) /* missing database name */
      61           0 :                 return 0;
      62             :         return 1;
      63             : }
      64             : 
      65             : /* assume valid uri's next functions */
      66             : 
      67             : /* mapiuri_uri prefix including database name */
      68             : const char *
      69          52 : mapiuri_uri( const char *uri, sql_allocator *sa)
      70             : {
      71             :         const char *p = uri, *b = uri, *e;
      72             : 
      73          52 :         p = strchr(p, '/')+1;
      74          52 :         p++;
      75          52 :         e = p = strchr(p, '/');
      76          52 :         e = strchr(p+1, '/');
      77          52 :         if (e)
      78          19 :                 return sa_strndup(sa, b, e - b);
      79             :         else
      80          33 :                 return sa_strdup(sa, b);
      81             : }
      82             : 
      83             : const char *
      84           0 : mapiuri_database( const char *uri, sql_allocator *sa)
      85             : {
      86             :         const char *p = uri, *b, *e;
      87             : 
      88           0 :         p = strchr(p, '/')+1;
      89           0 :         p++;
      90           0 :         b = p = strchr(p, '/')+1;
      91           0 :         e = strchr(p, '/');
      92             : 
      93           0 :         if (e) {
      94           0 :                 return sa_strndup(sa, b, e - b);
      95             :         } else {
      96           0 :                 return sa_strdup(sa, b);
      97             :         }
      98             : }
      99             : 
     100             : const char *
     101         128 : mapiuri_schema( const char *uri, sql_allocator *sa, const char *fallback)
     102             : {
     103             :         const char *p = uri, *b, *e;
     104             : 
     105         128 :         p = strchr(p, '/')+1;
     106         128 :         p = strchr(p+1, '/');
     107         128 :         p = strchr(p+1, '/');
     108         128 :         if (!p)
     109             :                 return fallback;
     110          94 :         b = ++p;
     111          94 :         e = strchr(p, '/');
     112             : 
     113          94 :         if (e) {
     114          94 :                 return sa_strndup(sa, b, e - b);
     115             :         } else {
     116           0 :                 return sa_strdup(sa, b);
     117             :         }
     118             : }
     119             : 
     120             : const char *
     121         328 : mapiuri_table( const char *uri, sql_allocator *sa, const char *fallback)
     122             : {
     123             :         const char *p = uri, *b;
     124             : 
     125         328 :         p = strchr(p, '/')+1;
     126         328 :         p = strchr(p+1, '/');
     127         328 :         p = strchr(p+1, '/');
     128         328 :         if (!p)
     129             :                 return fallback;
     130         219 :         p = strchr(p+1, '/');
     131         219 :         if (!p)
     132             :                 return fallback;
     133         219 :         b = ++p;
     134         219 :         return sa_strdup(sa, b);
     135             : }

Generated by: LCOV version 1.14