1/****************************************************************************** 2 * 3 * Copyright (C) 2003-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19/****************************************************************************** 20 * 21 * This file contains utility functions. 22 * 23 ******************************************************************************/ 24#include "utl.h" 25#include "gki.h" 26#include "btm_api.h" 27 28/******************************************************************************* 29** 30** Function utl_str2int 31** 32** Description This utility function converts a character string to an 33** integer. Acceptable values in string are 0-9. If invalid 34** string or string value too large, -1 is returned. Leading 35** spaces are skipped. 36** 37** 38** Returns Integer value or -1 on error. 39** 40*******************************************************************************/ 41INT16 utl_str2int(const char *p_s) 42{ 43 INT32 val = 0; 44 45 for (;*p_s == ' ' && *p_s != 0; p_s++); 46 47 if (*p_s == 0) return -1; 48 49 for (;;) 50 { 51 if ((*p_s < '0') || (*p_s > '9')) return -1; 52 53 val += (INT32) (*p_s++ - '0'); 54 55 if (val > 32767) return -1; 56 57 if (*p_s == 0) 58 { 59 return (INT16) val; 60 } 61 else 62 { 63 val *= 10; 64 } 65 } 66} 67 68/******************************************************************************* 69** 70** Function utl_strucmp 71** 72** Description This utility function compares two strings in uppercase. 73** String p_s must be uppercase. String p_t is converted to 74** uppercase if lowercase. If p_s ends first, the substring 75** match is counted as a match. 76** 77** 78** Returns 0 if strings match, nonzero otherwise. 79** 80*******************************************************************************/ 81int utl_strucmp(const char *p_s, const char *p_t) 82{ 83 char c; 84 85 while (*p_s && *p_t) 86 { 87 c = *p_t++; 88 if (c >= 'a' && c <= 'z') 89 { 90 c -= 0x20; 91 } 92 if (*p_s++ != c) 93 { 94 return -1; 95 } 96 } 97 /* if p_t hit null first, no match */ 98 if (*p_t == 0 && *p_s != 0) 99 { 100 return 1; 101 } 102 /* else p_s hit null first, count as match */ 103 else 104 { 105 return 0; 106 } 107} 108 109/******************************************************************************* 110** 111** Function utl_itoa 112** 113** Description This utility function converts a UINT16 to a string. The 114** string is NULL-terminated. The length of the string is 115** returned; 116** 117** 118** Returns Length of string. 119** 120*******************************************************************************/ 121UINT8 utl_itoa(UINT16 i, char *p_s) 122{ 123 UINT16 j, k; 124 char *p = p_s; 125 BOOLEAN fill = FALSE; 126 127 if (i == 0) 128 { 129 /* take care of zero case */ 130 *p++ = '0'; 131 } 132 else 133 { 134 for(j = 10000; j > 0; j /= 10) 135 { 136 k = i / j; 137 i %= j; 138 if (k > 0 || fill) 139 { 140 *p++ = k + '0'; 141 fill = TRUE; 142 } 143 } 144 } 145 *p = 0; 146 return (UINT8) (p - p_s); 147} 148 149/******************************************************************************* 150** 151** Function utl_freebuf 152** 153** Description This function calls GKI_freebuf to free the buffer passed 154** in, if buffer pointer is not NULL, and also initializes 155** buffer pointer to NULL. 156** 157** 158** Returns Nothing. 159** 160*******************************************************************************/ 161void utl_freebuf(void **p) 162{ 163 if (*p != NULL) 164 { 165 GKI_freebuf(*p); 166 *p = NULL; 167 } 168} 169 170 171/******************************************************************************* 172** 173** Function utl_set_device_class 174** 175** Description This function updates the local Device Class. 176** 177** Parameters: 178** p_cod - Pointer to the device class to set to 179** 180** cmd - the fields of the device class to update. 181** BTA_UTL_SET_COD_MAJOR_MINOR, - overwrite major, minor class 182** BTA_UTL_SET_COD_SERVICE_CLASS - set the bits in the input 183** BTA_UTL_CLR_COD_SERVICE_CLASS - clear the bits in the input 184** BTA_UTL_SET_COD_ALL - overwrite major, minor, set the bits in service class 185** BTA_UTL_INIT_COD - overwrite major, minor, and service class 186** 187** Returns TRUE if successful, Otherwise FALSE 188** 189*******************************************************************************/ 190BOOLEAN utl_set_device_class(tBTA_UTL_COD *p_cod, UINT8 cmd) 191{ 192 UINT8 *dev; 193 UINT16 service; 194 UINT8 minor, major; 195 DEV_CLASS dev_class; 196 197 dev = BTM_ReadDeviceClass(); 198 BTM_COD_SERVICE_CLASS( service, dev ); 199 BTM_COD_MINOR_CLASS(minor, dev ); 200 BTM_COD_MAJOR_CLASS(major, dev ); 201 202 switch(cmd) 203 { 204 case BTA_UTL_SET_COD_MAJOR_MINOR: 205 minor = p_cod->minor & BTM_COD_MINOR_CLASS_MASK; 206 major = p_cod->major & BTM_COD_MAJOR_CLASS_MASK; 207 break; 208 209 case BTA_UTL_SET_COD_SERVICE_CLASS: 210 /* clear out the bits that is not SERVICE_CLASS bits */ 211 p_cod->service &= BTM_COD_SERVICE_CLASS_MASK; 212 service = service | p_cod->service; 213 break; 214 215 case BTA_UTL_CLR_COD_SERVICE_CLASS: 216 p_cod->service &= BTM_COD_SERVICE_CLASS_MASK; 217 service = service & (~p_cod->service); 218 break; 219 220 case BTA_UTL_SET_COD_ALL: 221 minor = p_cod->minor & BTM_COD_MINOR_CLASS_MASK; 222 major = p_cod->major & BTM_COD_MAJOR_CLASS_MASK; 223 p_cod->service &= BTM_COD_SERVICE_CLASS_MASK; 224 service = service | p_cod->service; 225 break; 226 227 case BTA_UTL_INIT_COD: 228 minor = p_cod->minor & BTM_COD_MINOR_CLASS_MASK; 229 major = p_cod->major & BTM_COD_MAJOR_CLASS_MASK; 230 service = p_cod->service & BTM_COD_SERVICE_CLASS_MASK; 231 break; 232 233 default: 234 return FALSE; 235 } 236 237 /* convert the fields into the device class type */ 238 FIELDS_TO_COD(dev_class, minor, major, service); 239 240 if (BTM_SetDeviceClass(dev_class) == BTM_SUCCESS) 241 return TRUE; 242 243 return FALSE; 244} 245 246/******************************************************************************* 247** 248** Function utl_isintstr 249** 250** Description This utility function checks if the given string is an 251** integer string or not 252** 253** 254** Returns TRUE if successful, Otherwise FALSE 255** 256*******************************************************************************/ 257BOOLEAN utl_isintstr(const char *p_s) 258{ 259 UINT16 i = 0; 260 261 for(i=0; p_s[i] != 0; i++) 262 { 263 if(((p_s[i] < '0') || (p_s[i] > '9')) && (p_s[i] != ';')) 264 return FALSE; 265 } 266 267 return TRUE; 268} 269 270/******************************************************************************* 271** 272** Function utl_isdialstr 273** 274** Description This utility function checks if the given string contains 275** only dial digits or not 276** 277** 278** Returns TRUE if successful, Otherwise FALSE 279** 280*******************************************************************************/ 281BOOLEAN utl_isdialstr(const char *p_s) 282{ 283 UINT16 i = 0; 284 285 for(i=0; p_s[i] != 0; i++) 286 { 287 if(!(((p_s[i] >= '0') && (p_s[i] <= '9')) 288 || (p_s[i] == '*') || (p_s[i] == '+') || (p_s[i] == '#') || (p_s[i] == ';') 289 || ((p_s[i] >= 'A') && (p_s[i] <= 'C')))) 290 return FALSE; 291 } 292 293 return TRUE; 294} 295 296 297