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