Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/netisdn/i4b_l4mgmt.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* $NetBSD: i4b_l4mgmt.c,v 1.13 2003/10/03 16:38:44 pooka Exp $ */ 2 3 /* 4 * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 *--------------------------------------------------------------------------- 28 * 29 * i4b_l4mgmt.c - layer 4 calldescriptor management utilites 30 * ----------------------------------------------------------- 31 * 32 * $Id: i4b_l4mgmt.c,v 1.13 2003/10/03 16:38:44 pooka Exp $ 33 * 34 * $FreeBSD$ 35 * 36 * last edit-date: [Fri Jan 5 11:33:47 2001] 37 * 38 *---------------------------------------------------------------------------*/ 39 40 #include <sys/cdefs.h> 41 __KERNEL_RCSID(0, "$NetBSD: i4b_l4mgmt.c,v 1.13 2003/10/03 16:38:44 pooka Exp $"); 42 43 #include "isdn.h" 44 45 #if NISDN > 0 46 47 #include <sys/param.h> 48 #include <sys/kernel.h> 49 #include <sys/systm.h> 50 #include <sys/mbuf.h> 51 #include <sys/socket.h> 52 #include <net/if.h> 53 54 #if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000 55 #include <sys/callout.h> 56 #endif 57 58 #if defined(__FreeBSD__) 59 #if defined (__FreeBSD_version) && __FreeBSD_version <= 400000 60 #include <machine/random.h> 61 #else 62 #include <sys/random.h> 63 #endif 64 #endif 65 66 #ifdef __FreeBSD__ 67 #include <machine/i4b_debug.h> 68 #include <machine/i4b_ioctl.h> 69 #else 70 #include <netisdn/i4b_debug.h> 71 #include <netisdn/i4b_ioctl.h> 72 #endif 73 74 #include <netisdn/i4b_l3l4.h> 75 #include <netisdn/i4b_mbuf.h> 76 #include <netisdn/i4b_isdnq931.h> 77 #include <netisdn/i4b_global.h> 78 79 #include <netisdn/i4b_l2.h> 80 #include <netisdn/i4b_l1l2.h> 81 #include <netisdn/i4b_l4.h> 82 83 static unsigned int get_cdid(void); 84 85 static void i4b_init_callout(call_desc_t *); 86 static void i4b_stop_callout(call_desc_t *cd); 87 88 call_desc_t call_desc[N_CALL_DESC]; /* call descriptor array */ 89 int num_call_desc = 0; 90 91 /*---------------------------------------------------------------------------* 92 * return a new unique call descriptor id 93 * -------------------------------------- 94 * returns a new calldescriptor id which is used to uniquely identyfy 95 * a single call in the communication between kernel and userland. 96 * this cdid is then used to associate a calldescriptor with an id. 97 *---------------------------------------------------------------------------*/ 98 static unsigned int 99 get_cdid(void) 100 { 101 static unsigned int cdid_count = 0; 102 int i; 103 int x; 104 105 x = splnet(); 106 107 /* get next id */ 108 109 cdid_count++; 110 111 again: 112 if(cdid_count == CDID_UNUSED) /* zero is invalid */ 113 cdid_count++; 114 else if(cdid_count > CDID_MAX) /* wraparound ? */ 115 cdid_count = 1; 116 117 /* check if id already in use */ 118 119 for(i=0; i < num_call_desc; i++) 120 { 121 if(call_desc[i].cdid == cdid_count) 122 { 123 cdid_count++; 124 goto again; 125 } 126 } 127 128 splx(x); 129 130 return(cdid_count); 131 } 132 133 /*---------------------------------------------------------------------------* 134 * reserve a calldescriptor for later usage 135 * ---------------------------------------- 136 * searches the calldescriptor array until an unused 137 * descriptor is found, gets a new calldescriptor id 138 * and reserves it by putting the id into the cdid field. 139 * returns pointer to the calldescriptor. 140 *---------------------------------------------------------------------------*/ 141 call_desc_t * 142 reserve_cd(void) 143 { 144 call_desc_t *cd; 145 int x; 146 int i; 147 148 x = splnet(); 149 150 cd = NULL; 151 152 for(i=0; i < num_call_desc; i++) 153 { 154 if(call_desc[i].cdid == CDID_UNUSED) 155 { 156 cd = &(call_desc[i]); /* get pointer to descriptor */ 157 NDBGL4(L4_MSG, "found free cd - index=%d cdid=%u", 158 i, call_desc[i].cdid); 159 break; 160 } 161 } 162 if (cd == NULL && num_call_desc < N_CALL_DESC) { 163 i = num_call_desc++; 164 cd = &(call_desc[i]); /* get pointer to descriptor */ 165 NDBGL4(L4_MSG, "found free cd - index=%d cdid=%u", 166 i, call_desc[i].cdid); 167 } 168 if (cd != NULL) { 169 memset(cd, 0, sizeof(call_desc_t)); /* clear it */ 170 cd->cdid = get_cdid(); /* fill in new cdid */ 171 } 172 173 splx(x); 174 175 if(cd == NULL) 176 panic("reserve_cd: no free call descriptor available!"); 177 178 i4b_init_callout(cd); 179 180 return(cd); 181 } 182 183 /*---------------------------------------------------------------------------* 184 * free a calldescriptor 185 * --------------------- 186 * free a unused calldescriptor by giving address of calldescriptor 187 * and writing a 0 into the cdid field marking it as unused. 188 *---------------------------------------------------------------------------*/ 189 void 190 freecd_by_cd(call_desc_t *cd) 191 { 192 int i; 193 int x = splnet(); 194 195 for(i=0; i < num_call_desc; i++) 196 { 197 if( (call_desc[i].cdid != CDID_UNUSED) && 198 (&(call_desc[i]) == cd) ) 199 { 200 NDBGL4(L4_MSG, "releasing cd - index=%d cdid=%u cr=%d", 201 i, call_desc[i].cdid, cd->cr); 202 call_desc[i].cdid = CDID_UNUSED; 203 break; 204 } 205 } 206 207 if(i == N_CALL_DESC) 208 panic("freecd_by_cd: ERROR, cd not found, cr = %d", cd->cr); 209 210 splx(x); 211 } 212 213 /* 214 * ISDN is gone, get rid of all CDs for it 215 */ 216 void free_all_cd_of_isdnif(int isdnif) 217 { 218 int i; 219 int x = splnet(); 220 221 for(i=0; i < num_call_desc; i++) 222 { 223 if( (call_desc[i].cdid != CDID_UNUSED) && 224 call_desc[i].isdnif == isdnif) { 225 NDBGL4(L4_MSG, "releasing cd - index=%d cdid=%u cr=%d", 226 i, call_desc[i].cdid, call_desc[i].cr); 227 if (call_desc[i].callouts_inited) 228 i4b_stop_callout(&call_desc[i]); 229 call_desc[i].cdid = CDID_UNUSED; 230 call_desc[i].isdnif = -1; 231 call_desc[i].l3drv = NULL; 232 } 233 } 234 235 splx(x); 236 } 237 238 /*---------------------------------------------------------------------------* 239 * return pointer to calldescriptor by giving the calldescriptor id 240 * ---------------------------------------------------------------- 241 * lookup a calldescriptor in the calldescriptor array by looking 242 * at the cdid field. return pointer to calldescriptor if found, 243 * else return NULL if not found. 244 *---------------------------------------------------------------------------*/ 245 call_desc_t * 246 cd_by_cdid(unsigned int cdid) 247 { 248 int i; 249 250 for(i=0; i < num_call_desc; i++) 251 { 252 if(call_desc[i].cdid == cdid) 253 { 254 NDBGL4(L4_MSG, "found cdid - index=%d cdid=%u cr=%d", 255 i, call_desc[i].cdid, call_desc[i].cr); 256 i4b_init_callout(&call_desc[i]); 257 return(&(call_desc[i])); 258 } 259 } 260 return(NULL); 261 } 262 263 /*---------------------------------------------------------------------------* 264 * search calldescriptor 265 * --------------------- 266 * This routine searches for the calldescriptor for a passive controller 267 * given by unit number, callreference and callreference flag. 268 * It returns a pointer to the calldescriptor if found, else a NULL. 269 *---------------------------------------------------------------------------*/ 270 call_desc_t * 271 cd_by_isdnifcr(int isdnif, int cr, int crf) 272 { 273 int i; 274 275 for(i=0; i < num_call_desc; i++) { 276 if (call_desc[i].cdid != CDID_UNUSED 277 && call_desc[i].isdnif == isdnif 278 && call_desc[i].cr == cr 279 && call_desc[i].crflag == crf) { 280 NDBGL4(L4_MSG, "found cd, index=%d cdid=%u cr=%d", 281 i, call_desc[i].cdid, call_desc[i].cr); 282 i4b_init_callout(&call_desc[i]); 283 return(&(call_desc[i])); 284 } 285 } 286 return(NULL); 287 } 288 289 /*---------------------------------------------------------------------------* 290 * generate 7 bit "random" number used for outgoing Call Reference 291 *---------------------------------------------------------------------------*/ 292 unsigned char 293 get_rand_cr(int unit) 294 { 295 register int i, j; 296 static u_char val, retval; 297 static int called = 42; 298 299 val += ++called; 300 301 for(i=0; i < 50 ; i++, val++) 302 { 303 int found = 1; 304 305 #if defined(__FreeBSD__) 306 307 #ifdef RANDOMDEV 308 read_random((char *)&val, sizeof(val)); 309 #else 310 val = (u_char)random(); 311 #endif /* RANDOMDEV */ 312 313 #else 314 val |= unit+i; 315 val <<= i; 316 val ^= (time.tv_sec >> 8) ^ time.tv_usec; 317 val <<= i; 318 val ^= time.tv_sec ^ (time.tv_usec >> 8); 319 #endif 320 321 retval = val & 0x7f; 322 323 if(retval == 0 || retval == 0x7f) 324 continue; 325 326 for(j=0; j < num_call_desc; j++) 327 { 328 if( (call_desc[j].cdid != CDID_UNUSED) && 329 (call_desc[j].cr == retval) ) 330 { 331 found = 0; 332 break; 333 } 334 } 335 336 if(found) 337 return(retval); 338 } 339 return(0); /* XXX */ 340 } 341 342 static void 343 i4b_stop_callout(call_desc_t *cd) 344 { 345 if (!cd->callouts_inited) 346 return; 347 348 callout_stop(&cd->idle_timeout_handle); 349 callout_stop(&cd->T303_callout); 350 callout_stop(&cd->T305_callout); 351 callout_stop(&cd->T308_callout); 352 callout_stop(&cd->T309_callout); 353 callout_stop(&cd->T310_callout); 354 callout_stop(&cd->T313_callout); 355 callout_stop(&cd->T400_callout); 356 } 357 358 /*---------------------------------------------------------------------------* 359 * initialize the callout handles for FreeBSD 360 *---------------------------------------------------------------------------*/ 361 void 362 i4b_init_callout(call_desc_t *cd) 363 { 364 if(cd->callouts_inited == 0) 365 { 366 callout_init(&cd->idle_timeout_handle); 367 callout_init(&cd->T303_callout); 368 callout_init(&cd->T305_callout); 369 callout_init(&cd->T308_callout); 370 callout_init(&cd->T309_callout); 371 callout_init(&cd->T310_callout); 372 callout_init(&cd->T313_callout); 373 callout_init(&cd->T400_callout); 374 cd->callouts_inited = 1; 375 } 376 } 377 378 #ifdef I4B_CD_DEBUG_PRINT 379 380 extern char *print_l3state(call_desc_t *cd); 381 382 void i4b_print_cdp(call_desc_t *cdp); 383 void i4b_print_cdx(int index); 384 void i4b_print_cda(void); 385 void i4b_print_cdaa(void); 386 387 /*---------------------------------------------------------------------------* 388 * print a call descriptor by cd-pointer 389 *---------------------------------------------------------------------------*/ 390 void 391 i4b_print_cdp(call_desc_t *cdp) 392 { 393 if((cdp > &(call_desc[num_call_desc])) || (cdp < &(call_desc[0]))) 394 { 395 printf("i4b_print_cd: cdp out of range!\n"); 396 return; 397 } 398 399 printf("i4b_print_cd: printing call descriptor %d at 0x%lx:\n", cdp - (&(call_desc[0])), (unsigned long)cdp); 400 401 printf(" cdid = %d\n", cdp->cdid); 402 printf(" controller = %d (u=%d, dl=%d, b1=%d, b2=%d)\n", 403 cdp->controller, 404 ctrl_desc[cdp->controller].unit, 405 ctrl_desc[cdp->controller].dl_est, 406 ctrl_desc[cdp->controller].bch_state[CHAN_B1], 407 ctrl_desc[cdp->controller].bch_state[CHAN_B2]); 408 printf(" cr = 0x%02x\n", cdp->cr); 409 printf(" crflag = %d\n", cdp->crflag); 410 printf(" channelid = %d\n", cdp->channelid); 411 printf(" bprot = %d\n", cdp->bprot); 412 printf(" driver = %d\n", cdp->driver); 413 printf(" driver_unit = %d\n", cdp->driver_unit); 414 printf(" call_state = %d\n", cdp->call_state); 415 printf(" Q931state = %s\n", print_l3state(cdp)); 416 printf(" event = %d\n", cdp->event); 417 printf(" response = %d\n", cdp->response); 418 printf(" T303 = %d\n", cdp->T303); 419 printf("T303_first_to = %d\n", cdp->T303_first_to); 420 printf(" T305 = %d\n", cdp->T305); 421 printf(" T308 = %d\n", cdp->T308); 422 printf("T308_first_to = %d\n", cdp->T308_first_to); 423 printf(" T309 = %d\n", cdp->T309); 424 printf(" T310 = %d\n", cdp->T310); 425 printf(" T313 = %d\n", cdp->T313); 426 printf(" T400 = %d\n", cdp->T400); 427 printf(" dir = %s\n", cdp->dir == DIR_OUTGOING ? "out" : "in"); 428 } 429 430 /*---------------------------------------------------------------------------* 431 * print a call descriptor by index 432 *---------------------------------------------------------------------------*/ 433 void 434 i4b_print_cdx(int index) 435 { 436 if(index >= num_call_desc) 437 { 438 printf("i4b_print_cdx: index %d >= N_CALL_DESC %d\n", index, N_CALL_DESC); 439 return; 440 } 441 i4b_print_cdp(&(call_desc[index])); 442 } 443 444 /*---------------------------------------------------------------------------* 445 * print all call descriptors 446 *---------------------------------------------------------------------------*/ 447 void 448 i4b_print_cda(void) 449 { 450 int i; 451 452 for(i=0; i < num_call_desc; i++) 453 { 454 i4b_print_cdp(&(call_desc[i])); 455 } 456 } 457 458 /*---------------------------------------------------------------------------* 459 * print all active call descriptors 460 *---------------------------------------------------------------------------*/ 461 void 462 i4b_print_cdaa(void) 463 { 464 int i; 465 466 for(i=0; i < num_call_desc; i++) 467 { 468 if(call_desc[i].cdid != CDID_UNUSED) 469 { 470 i4b_print_cdp(&(call_desc[i])); 471 } 472 } 473 } 474 475 #endif /* I4B_CD_DEBUG_PRINT */ 476 477 #endif /* NISDN > 0 */
Cache object: b33512d77bbc73a7958a69d3d9726f78
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]