sbin/iscontrol/misc.c

   1 /*-
   2  * Copyright (c) 2005-2010 Daniel Braniss <danny@cs.huji.ac.il>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  */
  27
  28 /*
  29  | $Id: misc.c,v 2.1 2006/11/12 08:06:51 danny Exp $
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/types.h>
  37 #include <sys/socket.h>
  38 #include <sys/sysctl.h>
  39
  40 #include <netinet/in.h>
  41 #include <netinet/tcp.h>
  42 #include <arpa/inet.h>
  43 #if __FreeBSD_version < 500000
  44 #include <sys/time.h>
  45 #endif
  46 #include <stdlib.h>
  47 #include <stdio.h>
  48 #include <string.h>
  49
  50 #include <dev/iscsi/initiator/iscsi.h>
  51 #include "iscontrol.h"
  52
  53 static inline char
  54 c2b(unsigned char c)
  55 {
  56      switch(c) {
  57      case '0' ... '9':
  58           return c - '0';
  59      case 'a' ... 'f':
  60           return c - 'a' + 10;
  61      case 'A' ... 'F':
  62           return c - 'A' + 10;
  63      }
  64      return 0;
  65 }
  66
  67 static char     base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  68                            "abcdefghijklmnopqrstuvwxyz"
  69                            "0123456789+/";
  70
  71 static __inline unsigned char
  72 c64tobin(unsigned char c64)
  73 {
  74      int        i;
  75      for(i = 0; i < 64; i++)
  76           if(base64[i] == c64)
  77                break;
  78      return i;
  79 }
  80 /*
  81  | according to rfc3720, the binary string
  82  | cannot be larger than 1024 - but i can't find it :-) XXX
  83  | not enforced yet.
  84  */
  85 int
  86 str2bin(char *str, char **rsp)
  87 {
  88      char       *src, *dst, *tmp;
  89      int        i, len = 0;
  90
  91      src = str;
  92      tmp = NULL;
  93      if(strncasecmp("0x", src, 2) == 0) {
  94           src += 2;
  95           len = strlen(src);
  96
  97           if((tmp = malloc((len+1)/2)) == NULL) {
  98                // XXX: print some error?
  99                return 0;
 100           }
 101           dst = tmp;
 102           if(len & 1)
 103                *dst++ = c2b(*src++);
 104           while(*src) {
 105                *dst = c2b(*src++) << 4;
 106                *dst++ |= c2b(*src++);
 107           }
 108           len = dst - tmp;
 109      } else
 110      if(strncasecmp("0b", src , 2) == 0) {
 111           // base64
 112           unsigned char b6;
 113
 114           src += 2;
 115           len = strlen(src) / 4 * 3;
 116           if((tmp = malloc(len)) == NULL) {
 117                // XXX: print some error?
 118                return 0;
 119           }
 120           dst = tmp;
 121           i = 0;
 122           while(*src && ((b6 = c64tobin(*src++)) != 64)) {
 123                switch(i % 4) {
 124                case 0:
 125                     *dst = b6 << 2;
 126                     break;
 127                case 1:
 128                     *dst++ |= b6 >> 4;
 129                     *dst = b6 << 4;
 130                     break;
 131                case 2:
 132                     *dst++ |= b6 >> 2;
 133                     *dst = b6 << 6;
 134                     break;
 135                case 3:
 136                     *dst++ |= b6;
 137                     break;
 138                }
 139                i++;
 140           }
 141           len = dst - tmp;
 142      }
 143      else {
 144           /*
 145            | assume it to be an ascii string, so just copy it
 146            */
 147           len = strlen(str);
 148           if((tmp = malloc(len)) == NULL)
 149                return 0;
 150           dst = tmp;
 151           src = str;
 152           while(*src)
 153                *dst++ = *src++;
 154      }
 155
 156      *rsp = tmp;
 157      return len;
 158 }
 159
 160 char *
 161 bin2str(char *encoding, unsigned char *md, int blen)
 162 {
 163      int        len;
 164      char       *dst, *ds;
 165      unsigned char *cp;
 166
 167      if(strncasecmp(encoding, "0x", 2) == 0) {
 168           char  ofmt[5];
 169
 170           len = blen * 2;
 171           dst = malloc(len + 3);
 172           strcpy(dst, encoding);
 173           ds = dst + 2;
 174           cp = md;
 175           sprintf(ofmt, "%%02%c", encoding[1]);
 176           while(blen-- > 0) {
 177                sprintf(ds, ofmt, *cp++);
 178                ds += 2;
 179           }
 180           *ds = 0;
 181           return dst;
 182      }
 183      if(strncasecmp(encoding, "0b", 2) == 0) {
 184           int i, b6;
 185
 186           len = (blen + 2) * 4 / 3;
 187           dst = malloc(len + 3);
 188           strcpy(dst, encoding);
 189           ds = dst + 2;
 190           cp = md;
 191           b6 = 0; // to keep compiler happy.
 192           for(i = 0; i < blen; i++) {
 193                switch(i % 3) {
 194                case 0:
 195                     *ds++ = base64[*cp >> 2];
 196                     b6 = (*cp & 0x3) << 4;
 197                     break;
 198                case 1:
 199                     b6 += (*cp >> 4);
 200                     *ds++ = base64[b6];
 201                     b6 = (*cp & 0xf) << 2;
 202                     break;
 203                case 2:
 204                     b6 += (*cp >> 6);
 205                     *ds++ = base64[b6];
 206                     *ds++ = base64[*cp & 0x3f];
 207                }
 208                cp++;
 209           }
 210           switch(blen % 3) {
 211           case 0:
 212                break;
 213           case 1:
 214                *ds++ = base64[b6];
 215                *ds++ = '=';
 216                *ds++ = '=';
 217                break;
 218           case 2:
 219                *ds++ = base64[b6];
 220                *ds++ = '=';
 221                break;
 222           }
 223
 224           *ds = 0;
 225           return dst;
 226      }
 227
 228      return NULL;
 229 }