- Timestamp:
- 12/31/06 14:31:50 (5 years ago)
- Location:
- trunk/ithildin
- Files:
-
- 1 added
- 6 edited
-
include/ithildin/callback.h (added)
-
include/ithildin/ithildin.h (modified) (1 diff)
-
include/ithildin/queue.h (modified) (10 diffs)
-
include/ithildin/socket.h (modified) (1 diff)
-
lib/SConscript (modified) (1 diff)
-
lib/module.c (modified) (7 diffs)
-
lib/socket.c (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
trunk/ithildin/include/ithildin/ithildin.h
r787 r798 122 122 #endif 123 123 124 #include <ithildin/callback.h> 124 125 #include <ithildin/conf.h> 125 126 #include <ithildin/event.h> -
trunk/ithildin/include/ithildin/queue.h
r630 r798 133 133 * opted to remove the advertising provision. 134 134 */ 135 /* 135 136 /*- 136 137 * Copyright (c) 1991, 1993 137 * 138 * The Regents of the University of California. All rights reserved. 138 139 * 139 140 * Redistribution and use in source and binary forms, with or without … … 145 146 * notice, this list of conditions and the following disclaimer in the 146 147 * documentation and/or other materials provided with the distribution. 147 * 3. Neither the name of the University nor the names of its contributors148 * 4. Neither the name of the University nor the names of its contributors 148 149 * may be used to endorse or promote products derived from this software 149 150 * without specific prior written permission. … … 161 162 * SUCH DAMAGE. 162 163 * 163 * @(#)queue.h8.5 (Berkeley) 8/20/94164 * $FreeBSD: src/sys/sys/queue.h,v 1.5 4 2002/08/05 05:18:43 alfredExp $164 * @(#)queue.h 8.5 (Berkeley) 8/20/94 165 * $FreeBSD: src/sys/sys/queue.h,v 1.58.2.1 2005/01/31 23:26:57 imp Exp $ 165 166 */ 166 167 … … 207 208 * 208 209 * 209 * SLIST LIST STAILQ TAILQ 210 * _HEAD + + + + 211 * _HEAD_INITIALIZER + + + + 212 * _ENTRY + + + + 213 * _INIT + + + + 214 * _EMPTY + + + + 215 * _FIRST + + + + 216 * _NEXT + + + + 217 * _PREV - - - + 218 * _LAST - - + + 219 * _FOREACH + + + + 220 * _FOREACH_REVERSE - - - + 221 * _INSERT_HEAD + + + + 222 * _INSERT_BEFORE - + - + 223 * _INSERT_AFTER + + + + 224 * _INSERT_TAIL - - + + 225 * _CONCAT - - + + 226 * _REMOVE_HEAD + - + - 227 * _REMOVE + + + + 228 * 229 */ 230 #ifdef QUEUE_MACRO_DEBUG 210 * SLIST LIST STAILQ TAILQ 211 * _HEAD + + + + 212 * _HEAD_INITIALIZER + + + + 213 * _ENTRY + + + + 214 * _INIT + + + + 215 * _EMPTY + + + + 216 * _FIRST + + + + 217 * _NEXT + + + + 218 * _PREV - - - + 219 * _LAST - - + + 220 * _FOREACH + + + + 221 * _FOREACH_SAFE + + + + 222 * _FOREACH_REVERSE - - - + 223 * _FOREACH_REVERSE_SAFE - - - + 224 * _INSERT_HEAD + + + + 225 * _INSERT_BEFORE - + - + 226 * _INSERT_AFTER + + + + 227 * _INSERT_TAIL - - + + 228 * _CONCAT - - + + 229 * _REMOVE_HEAD + - + - 230 * _REMOVE + + + + 231 * 232 */ 233 #define QUEUE_MACRO_DEBUG 0 234 #if QUEUE_MACRO_DEBUG 231 235 /* Store the last 2 places the queue element or head was altered */ 232 236 struct qm_trace { 233 234 235 236 237 char * lastfile; 238 int lastline; 239 char * prevfile; 240 int prevline; 237 241 }; 238 242 239 #define TRACEBUFstruct qm_trace trace;240 #define TRASHIT(x)do {(x) = (void *)-1;} while (0)241 242 #define QMD_TRACE_HEAD(head) do {\243 (head)->trace.prevline = (head)->trace.lastline;\244 (head)->trace.prevfile = (head)->trace.lastfile;\245 (head)->trace.lastline = __LINE__;\246 (head)->trace.lastfile = __FILE__;\247 } while (0) 248 249 #define QMD_TRACE_ELEM(elem) do {\250 (elem)->trace.prevline = (elem)->trace.lastline;\251 (elem)->trace.prevfile = (elem)->trace.lastfile;\252 (elem)->trace.lastline = __LINE__;\253 (elem)->trace.lastfile = __FILE__;\243 #define TRACEBUF struct qm_trace trace; 244 #define TRASHIT(x) do {(x) = (void *)-1;} while (0) 245 246 #define QMD_TRACE_HEAD(head) do { \ 247 (head)->trace.prevline = (head)->trace.lastline; \ 248 (head)->trace.prevfile = (head)->trace.lastfile; \ 249 (head)->trace.lastline = __LINE__; \ 250 (head)->trace.lastfile = __FILE__; \ 251 } while (0) 252 253 #define QMD_TRACE_ELEM(elem) do { \ 254 (elem)->trace.prevline = (elem)->trace.lastline; \ 255 (elem)->trace.prevfile = (elem)->trace.lastfile; \ 256 (elem)->trace.lastline = __LINE__; \ 257 (elem)->trace.lastfile = __FILE__; \ 254 258 } while (0) 255 259 256 260 #else 257 #define 258 #define 259 #define 260 #define 261 #endif 261 #define QMD_TRACE_ELEM(elem) 262 #define QMD_TRACE_HEAD(head) 263 #define TRACEBUF 264 #define TRASHIT(x) 265 #endif /* QUEUE_MACRO_DEBUG */ 262 266 263 267 /* 264 268 * Singly-linked List declarations. 265 269 */ 266 #define SLIST_HEAD(name, type)\267 struct name { 268 struct type *slh_first; /* first element */\269 } 270 271 #define SLIST_HEAD_INITIALIZER(head)\272 273 274 #define SLIST_ENTRY(type)\275 struct { 276 struct type *sle_next; /* next element */\277 } 278 270 #define SLIST_HEAD(name, type) \ 271 struct name { \ 272 struct type *slh_first; /* first element */ \ 273 } 274 275 #define SLIST_HEAD_INITIALIZER(head) \ 276 { NULL } 277 278 #define SLIST_ENTRY(type) \ 279 struct { \ 280 struct type *sle_next; /* next element */ \ 281 } 282 279 283 /* 280 284 * Singly-linked List functions. 281 285 */ 282 #define SLIST_EMPTY(head) ((head)->slh_first == NULL) 283 284 #define SLIST_FIRST(head) ((head)->slh_first) 285 286 #define SLIST_FOREACH(var, head, field) \ 287 for ((var) = SLIST_FIRST((head)); \ 288 (var); \ 289 (var) = SLIST_NEXT((var), field)) 290 291 #define SLIST_FOREACH_PREVPTR(var, varp, head, field) \ 292 for ((varp) = &SLIST_FIRST((head)); \ 293 ((var) = *(varp)) != NULL; \ 294 (varp) = &SLIST_NEXT((var), field)) 295 296 #define SLIST_INIT(head) do { \ 297 SLIST_FIRST((head)) = NULL; \ 298 } while (0) 299 300 #define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ 301 SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \ 302 SLIST_NEXT((slistelm), field) = (elm); \ 303 } while (0) 304 305 #define SLIST_INSERT_HEAD(head, elm, field) do { \ 306 SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \ 307 SLIST_FIRST((head)) = (elm); \ 308 } while (0) 309 310 #define SLIST_NEXT(elm, field) ((elm)->field.sle_next) 311 312 #define SLIST_REMOVE(head, elm, type, field) do { \ 313 if (SLIST_FIRST((head)) == (elm)) { \ 314 SLIST_REMOVE_HEAD((head), field); \ 315 } \ 316 else { \ 317 struct type *curelm = SLIST_FIRST((head)); \ 318 while (SLIST_NEXT(curelm, field) != (elm)) \ 319 curelm = SLIST_NEXT(curelm, field); \ 320 SLIST_NEXT(curelm, field) = \ 321 SLIST_NEXT(SLIST_NEXT(curelm, field), field); \ 322 } \ 323 } while (0) 324 325 #define SLIST_REMOVE_HEAD(head, field) do { \ 326 SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \ 286 #define SLIST_EMPTY(head) ((head)->slh_first == NULL) 287 288 #define SLIST_FIRST(head) ((head)->slh_first) 289 290 #define SLIST_FOREACH(var, head, field) \ 291 for ((var) = SLIST_FIRST((head)); \ 292 (var); \ 293 (var) = SLIST_NEXT((var), field)) 294 295 #define SLIST_FOREACH_SAFE(var, head, field, tvar) \ 296 for ((var) = SLIST_FIRST((head)); \ 297 (var) && ((tvar) = SLIST_NEXT((var), field), 1); \ 298 (var) = (tvar)) 299 300 #define SLIST_FOREACH_PREVPTR(var, varp, head, field) \ 301 for ((varp) = &SLIST_FIRST((head)); \ 302 ((var) = *(varp)) != NULL; \ 303 (varp) = &SLIST_NEXT((var), field)) 304 305 #define SLIST_INIT(head) do { \ 306 SLIST_FIRST((head)) = NULL; \ 307 } while (0) 308 309 #define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ 310 SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \ 311 SLIST_NEXT((slistelm), field) = (elm); \ 312 } while (0) 313 314 #define SLIST_INSERT_HEAD(head, elm, field) do { \ 315 SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \ 316 SLIST_FIRST((head)) = (elm); \ 317 } while (0) 318 319 #define SLIST_NEXT(elm, field) ((elm)->field.sle_next) 320 321 #define SLIST_REMOVE(head, elm, type, field) do { \ 322 if (SLIST_FIRST((head)) == (elm)) { \ 323 SLIST_REMOVE_HEAD((head), field); \ 324 } \ 325 else { \ 326 struct type *curelm = SLIST_FIRST((head)); \ 327 while (SLIST_NEXT(curelm, field) != (elm)) \ 328 curelm = SLIST_NEXT(curelm, field); \ 329 SLIST_NEXT(curelm, field) = \ 330 SLIST_NEXT(SLIST_NEXT(curelm, field), field); \ 331 } \ 332 } while (0) 333 334 #define SLIST_REMOVE_HEAD(head, field) do { \ 335 SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \ 327 336 } while (0) 328 337 … … 330 339 * Singly-linked Tail queue declarations. 331 340 */ 332 #define STAILQ_HEAD(name, type)\333 struct name { 334 struct type *stqh_first;/* first element */\335 struct type **stqh_last;/* addr of last next element */\336 } 337 338 #define STAILQ_HEAD_INITIALIZER(head)\339 340 341 #define STAILQ_ENTRY(type)\342 struct { 343 struct type *stqe_next; /* next element */\341 #define STAILQ_HEAD(name, type) \ 342 struct name { \ 343 struct type *stqh_first;/* first element */ \ 344 struct type **stqh_last;/* addr of last next element */ \ 345 } 346 347 #define STAILQ_HEAD_INITIALIZER(head) \ 348 { NULL, &(head).stqh_first } 349 350 #define STAILQ_ENTRY(type) \ 351 struct { \ 352 struct type *stqe_next; /* next element */ \ 344 353 } 345 354 … … 347 356 * Singly-linked Tail queue functions. 348 357 */ 349 #define STAILQ_CONCAT(head1, head2) do { \ 350 if (!STAILQ_EMPTY((head2))) { \ 351 *(head1)->stqh_last = (head2)->stqh_first; \ 352 (head1)->stqh_last = (head2)->stqh_last; \ 353 STAILQ_INIT((head2)); \ 354 } \ 355 } while (0) 356 357 #define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) 358 359 #define STAILQ_FIRST(head) ((head)->stqh_first) 360 361 #define STAILQ_FOREACH(var, head, field) \ 362 for((var) = STAILQ_FIRST((head)); \ 363 (var); \ 364 (var) = STAILQ_NEXT((var), field)) 365 366 #define STAILQ_INIT(head) do { \ 367 STAILQ_FIRST((head)) = NULL; \ 368 (head)->stqh_last = &STAILQ_FIRST((head)); \ 369 } while (0) 370 371 #define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \ 372 if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL) \ 373 (head)->stqh_last = &STAILQ_NEXT((elm), field); \ 374 STAILQ_NEXT((tqelm), field) = (elm); \ 375 } while (0) 376 377 #define STAILQ_INSERT_HEAD(head, elm, field) do { \ 378 if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \ 379 (head)->stqh_last = &STAILQ_NEXT((elm), field); \ 380 STAILQ_FIRST((head)) = (elm); \ 381 } while (0) 382 383 #define STAILQ_INSERT_TAIL(head, elm, field) do { \ 384 STAILQ_NEXT((elm), field) = NULL; \ 385 *(head)->stqh_last = (elm); \ 386 (head)->stqh_last = &STAILQ_NEXT((elm), field); \ 387 } while (0) 388 389 #define STAILQ_LAST(head, type, field) \ 390 (STAILQ_EMPTY((head)) ? \ 391 NULL : \ 392 ((struct type *) \ 393 ((char *)((head)->stqh_last) - __offsetof(struct type, field)))) 394 395 #define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) 396 397 #define STAILQ_REMOVE(head, elm, type, field) do { \ 398 if (STAILQ_FIRST((head)) == (elm)) { \ 399 STAILQ_REMOVE_HEAD((head), field); \ 400 } \ 401 else { \ 402 struct type *curelm = STAILQ_FIRST((head)); \ 403 while (STAILQ_NEXT(curelm, field) != (elm)) \ 404 curelm = STAILQ_NEXT(curelm, field); \ 405 if ((STAILQ_NEXT(curelm, field) = \ 406 STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL) \ 407 (head)->stqh_last = &STAILQ_NEXT((curelm), field); \ 408 } \ 409 } while (0) 410 411 #define STAILQ_REMOVE_HEAD(head, field) do { \ 412 if ((STAILQ_FIRST((head)) = \ 413 STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \ 414 (head)->stqh_last = &STAILQ_FIRST((head)); \ 415 } while (0) 416 417 #define STAILQ_REMOVE_HEAD_UNTIL(head, elm, field) do { \ 418 if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL) \ 419 (head)->stqh_last = &STAILQ_FIRST((head)); \ 358 #define STAILQ_CONCAT(head1, head2) do { \ 359 if (!STAILQ_EMPTY((head2))) { \ 360 *(head1)->stqh_last = (head2)->stqh_first; \ 361 (head1)->stqh_last = (head2)->stqh_last; \ 362 STAILQ_INIT((head2)); \ 363 } \ 364 } while (0) 365 366 #define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) 367 368 #define STAILQ_FIRST(head) ((head)->stqh_first) 369 370 #define STAILQ_FOREACH(var, head, field) \ 371 for((var) = STAILQ_FIRST((head)); \ 372 (var); \ 373 (var) = STAILQ_NEXT((var), field)) 374 375 376 #define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ 377 for ((var) = STAILQ_FIRST((head)); \ 378 (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \ 379 (var) = (tvar)) 380 381 #define STAILQ_INIT(head) do { \ 382 STAILQ_FIRST((head)) = NULL; \ 383 (head)->stqh_last = &STAILQ_FIRST((head)); \ 384 } while (0) 385 386 #define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \ 387 if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\ 388 (head)->stqh_last = &STAILQ_NEXT((elm), field); \ 389 STAILQ_NEXT((tqelm), field) = (elm); \ 390 } while (0) 391 392 #define STAILQ_INSERT_HEAD(head, elm, field) do { \ 393 if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \ 394 (head)->stqh_last = &STAILQ_NEXT((elm), field); \ 395 STAILQ_FIRST((head)) = (elm); \ 396 } while (0) 397 398 #define STAILQ_INSERT_TAIL(head, elm, field) do { \ 399 STAILQ_NEXT((elm), field) = NULL; \ 400 *(head)->stqh_last = (elm); \ 401 (head)->stqh_last = &STAILQ_NEXT((elm), field); \ 402 } while (0) 403 404 #define STAILQ_LAST(head, type, field) \ 405 (STAILQ_EMPTY((head)) ? \ 406 NULL : \ 407 ((struct type *) \ 408 ((char *)((head)->stqh_last) - __offsetof(struct type, field)))) 409 410 #define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) 411 412 #define STAILQ_REMOVE(head, elm, type, field) do { \ 413 if (STAILQ_FIRST((head)) == (elm)) { \ 414 STAILQ_REMOVE_HEAD((head), field); \ 415 } \ 416 else { \ 417 struct type *curelm = STAILQ_FIRST((head)); \ 418 while (STAILQ_NEXT(curelm, field) != (elm)) \ 419 curelm = STAILQ_NEXT(curelm, field); \ 420 if ((STAILQ_NEXT(curelm, field) = \ 421 STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\ 422 (head)->stqh_last = &STAILQ_NEXT((curelm), field);\ 423 } \ 424 } while (0) 425 426 #define STAILQ_REMOVE_HEAD(head, field) do { \ 427 if ((STAILQ_FIRST((head)) = \ 428 STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \ 429 (head)->stqh_last = &STAILQ_FIRST((head)); \ 430 } while (0) 431 432 #define STAILQ_REMOVE_HEAD_UNTIL(head, elm, field) do { \ 433 if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL) \ 434 (head)->stqh_last = &STAILQ_FIRST((head)); \ 420 435 } while (0) 421 436 … … 423 438 * List declarations. 424 439 */ 425 #define LIST_HEAD(name, type)\426 struct name { 427 struct type *lh_first; /* first element */\428 } 429 430 #define LIST_HEAD_INITIALIZER(head)\431 432 433 #define LIST_ENTRY(type)\434 struct { 435 struct type *le_next; /* next element */\436 struct type **le_prev; /* address of previous next element */\440 #define LIST_HEAD(name, type) \ 441 struct name { \ 442 struct type *lh_first; /* first element */ \ 443 } 444 445 #define LIST_HEAD_INITIALIZER(head) \ 446 { NULL } 447 448 #define LIST_ENTRY(type) \ 449 struct { \ 450 struct type *le_next; /* next element */ \ 451 struct type **le_prev; /* address of previous next element */ \ 437 452 } 438 453 … … 441 456 */ 442 457 443 #define LIST_EMPTY(head) ((head)->lh_first == NULL) 444 445 #define LIST_FIRST(head) ((head)->lh_first) 446 447 #define LIST_FOREACH(var, head, field) \ 448 for ((var) = LIST_FIRST((head)); \ 449 (var); \ 450 (var) = LIST_NEXT((var), field)) 451 452 #define LIST_INIT(head) do { \ 453 LIST_FIRST((head)) = NULL; \ 454 } while (0) 455 456 #define LIST_INSERT_AFTER(listelm, elm, field) do { \ 457 if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL) \ 458 LIST_NEXT((listelm), field)->field.le_prev = \ 459 &LIST_NEXT((elm), field); \ 460 LIST_NEXT((listelm), field) = (elm); \ 461 (elm)->field.le_prev = &LIST_NEXT((listelm), field); \ 462 } while (0) 463 464 #define LIST_INSERT_BEFORE(listelm, elm, field) do { \ 465 (elm)->field.le_prev = (listelm)->field.le_prev; \ 466 LIST_NEXT((elm), field) = (listelm); \ 467 *(listelm)->field.le_prev = (elm); \ 468 (listelm)->field.le_prev = &LIST_NEXT((elm), field); \ 469 } while (0) 470 471 #define LIST_INSERT_HEAD(head, elm, field) do { \ 472 if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \ 473 LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field); \ 474 LIST_FIRST((head)) = (elm); \ 475 (elm)->field.le_prev = &LIST_FIRST((head)); \ 476 } while (0) 477 478 #define LIST_NEXT(elm, field) ((elm)->field.le_next) 479 480 #define LIST_REMOVE(elm, field) do { \ 481 if (LIST_NEXT((elm), field) != NULL) \ 482 LIST_NEXT((elm), field)->field.le_prev = \ 483 (elm)->field.le_prev; \ 484 *(elm)->field.le_prev = LIST_NEXT((elm), field); \ 458 #define LIST_EMPTY(head) ((head)->lh_first == NULL) 459 460 #define LIST_FIRST(head) ((head)->lh_first) 461 462 #define LIST_FOREACH(var, head, field) \ 463 for ((var) = LIST_FIRST((head)); \ 464 (var); \ 465 (var) = LIST_NEXT((var), field)) 466 467 #define LIST_FOREACH_SAFE(var, head, field, tvar) \ 468 for ((var) = LIST_FIRST((head)); \ 469 (var) && ((tvar) = LIST_NEXT((var), field), 1); \ 470 (var) = (tvar)) 471 472 #define LIST_INIT(head) do { \ 473 LIST_FIRST((head)) = NULL; \ 474 } while (0) 475 476 #define LIST_INSERT_AFTER(listelm, elm, field) do { \ 477 if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\ 478 LIST_NEXT((listelm), field)->field.le_prev = \ 479 &LIST_NEXT((elm), field); \ 480 LIST_NEXT((listelm), field) = (elm); \ 481 (elm)->field.le_prev = &LIST_NEXT((listelm), field); \ 482 } while (0) 483 484 #define LIST_INSERT_BEFORE(listelm, elm, field) do { \ 485 (elm)->field.le_prev = (listelm)->field.le_prev; \ 486 LIST_NEXT((elm), field) = (listelm); \ 487 *(listelm)->field.le_prev = (elm); \ 488 (listelm)->field.le_prev = &LIST_NEXT((elm), field); \ 489 } while (0) 490 491 #define LIST_INSERT_HEAD(head, elm, field) do { \ 492 if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \ 493 LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\ 494 LIST_FIRST((head)) = (elm); \ 495 (elm)->field.le_prev = &LIST_FIRST((head)); \ 496 } while (0) 497 498 #define LIST_NEXT(elm, field) ((elm)->field.le_next) 499 500 #define LIST_REMOVE(elm, field) do { \ 501 if (LIST_NEXT((elm), field) != NULL) \ 502 LIST_NEXT((elm), field)->field.le_prev = \ 503 (elm)->field.le_prev; \ 504 *(elm)->field.le_prev = LIST_NEXT((elm), field); \ 485 505 } while (0) 486 506 … … 488 508 * Tail queue declarations. 489 509 */ 490 #define TAILQ_HEAD(name, type)\491 struct name { 492 struct type *tqh_first; /* first element */\493 struct type **tqh_last; /* addr of last next element */\494 TRACEBUF\495 } 496 497 #define TAILQ_HEAD_INITIALIZER(head)\498 499 500 #define TAILQ_ENTRY(type)\501 struct { 502 struct type *tqe_next; /* next element */\503 struct type **tqe_prev; /* address of previous next element */\504 TRACEBUF\510 #define TAILQ_HEAD(name, type) \ 511 struct name { \ 512 struct type *tqh_first; /* first element */ \ 513 struct type **tqh_last; /* addr of last next element */ \ 514 TRACEBUF \ 515 } 516 517 #define TAILQ_HEAD_INITIALIZER(head) \ 518 { NULL, &(head).tqh_first } 519 520 #define TAILQ_ENTRY(type) \ 521 struct { \ 522 struct type *tqe_next; /* next element */ \ 523 struct type **tqe_prev; /* address of previous next element */ \ 524 TRACEBUF \ 505 525 } 506 526 … … 508 528 * Tail queue functions. 509 529 */ 510 #define TAILQ_CONCAT(head1, head2, field) do { \ 511 if (!TAILQ_EMPTY(head2)) { \ 512 *(head1)->tqh_last = (head2)->tqh_first; \ 513 (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \ 514 (head1)->tqh_last = (head2)->tqh_last; \ 515 TAILQ_INIT((head2)); \ 516 QMD_TRACE_HEAD(head); \ 517 QMD_TRACE_HEAD(head2); \ 518 } \ 519 } while (0) 520 521 #define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) 522 523 #define TAILQ_FIRST(head) ((head)->tqh_first) 524 525 #define TAILQ_FOREACH(var, head, field) \ 526 for ((var) = TAILQ_FIRST((head)); \ 527 (var); \ 528 (var) = TAILQ_NEXT((var), field)) 529 530 #define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ 531 for ((var) = TAILQ_LAST((head), headname); \ 532 (var); \ 533 (var) = TAILQ_PREV((var), headname, field)) 534 535 #define TAILQ_INIT(head) do { \ 536 TAILQ_FIRST((head)) = NULL; \ 537 (head)->tqh_last = &TAILQ_FIRST((head)); \ 538 QMD_TRACE_HEAD(head); \ 539 } while (0) 540 541 #define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ 542 if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL) \ 543 TAILQ_NEXT((elm), field)->field.tqe_prev = \ 544 &TAILQ_NEXT((elm), field); \ 545 else { \ 546 (head)->tqh_last = &TAILQ_NEXT((elm), field); \ 547 QMD_TRACE_HEAD(head); \ 548 } \ 549 TAILQ_NEXT((listelm), field) = (elm); \ 550 (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \ 551 QMD_TRACE_ELEM(&(elm)->field); \ 552 QMD_TRACE_ELEM(&listelm->field); \ 553 } while (0) 554 555 #define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ 556 (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ 557 TAILQ_NEXT((elm), field) = (listelm); \ 558 *(listelm)->field.tqe_prev = (elm); \ 559 (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \ 560 QMD_TRACE_ELEM(&(elm)->field); \ 561 QMD_TRACE_ELEM(&listelm->field); \ 562 } while (0) 563 564 #define TAILQ_INSERT_HEAD(head, elm, field) do { \ 565 if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \ 566 TAILQ_FIRST((head))->field.tqe_prev = \ 567 &TAILQ_NEXT((elm), field); \ 568 else \ 569 (head)->tqh_last = &TAILQ_NEXT((elm), field); \ 570 TAILQ_FIRST((head)) = (elm); \ 571 (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \ 572 QMD_TRACE_HEAD(head); \ 573 QMD_TRACE_ELEM(&(elm)->field); \ 574 } while (0) 575 576 #define TAILQ_INSERT_TAIL(head, elm, field) do { \ 577 TAILQ_NEXT((elm), field) = NULL; \ 578 (elm)->field.tqe_prev = (head)->tqh_last; \ 579 *(head)->tqh_last = (elm); \ 580 (head)->tqh_last = &TAILQ_NEXT((elm), field); \ 581 QMD_TRACE_HEAD(head); \ 582 QMD_TRACE_ELEM(&(elm)->field); \ 583 } while (0) 584 585 #define TAILQ_LAST(head, headname) \ 586 (*(((struct headname *)((head)->tqh_last))->tqh_last)) 587 588 #define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) 589 590 #define TAILQ_PREV(elm, headname, field) \ 591 (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) 592 593 #define TAILQ_REMOVE(head, elm, field) do { \ 594 if ((TAILQ_NEXT((elm), field)) != NULL) \ 595 TAILQ_NEXT((elm), field)->field.tqe_prev = \ 596 (elm)->field.tqe_prev; \ 597 else { \ 598 (head)->tqh_last = (elm)->field.tqe_prev; \ 599 QMD_TRACE_HEAD(head); \ 600 } \ 601 *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \ 602 TRASHIT((elm)->field.tqe_next); \ 603 TRASHIT((elm)->field.tqe_prev); \ 604 QMD_TRACE_ELEM(&(elm)->field); \ 605 } while (0) 606 607 #endif /* !QUEUE_H */ 530 #define TAILQ_CONCAT(head1, head2, field) do { \ 531 if (!TAILQ_EMPTY(head2)) { \ 532 *(head1)->tqh_last = (head2)->tqh_first; \ 533 (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \ 534 (head1)->tqh_last = (head2)->tqh_last; \ 535 TAILQ_INIT((head2)); \ 536 QMD_TRACE_HEAD(head); \ 537 QMD_TRACE_HEAD(head2); \ 538 } \ 539 } while (0) 540 541 #define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) 542 543 #define TAILQ_FIRST(head) ((head)->tqh_first) 544 545 #define TAILQ_FOREACH(var, head, field) \ 546 for ((var) = TAILQ_FIRST((head)); \ 547 (var); \ 548 (var) = TAILQ_NEXT((var), field)) 549 550 #define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ 551 for ((var) = TAILQ_FIRST((head)); \ 552 (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \ 553 (var) = (tvar)) 554 555 #define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ 556 for ((var) = TAILQ_LAST((head), headname); \ 557 (var); \ 558 (var) = TAILQ_PREV((var), headname, field)) 559 560 #define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ 561 for ((var) = TAILQ_LAST((head), headname); \ 562 (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \ 563 (var) = (tvar)) 564 565 #define TAILQ_INIT(head) do { \ 566 TAILQ_FIRST((head)) = NULL; \ 567 (head)->tqh_last = &TAILQ_FIRST((head)); \ 568 QMD_TRACE_HEAD(head); \ 569 } while (0) 570 571 #define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ 572 if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\ 573 TAILQ_NEXT((elm), field)->field.tqe_prev = \ 574 &TAILQ_NEXT((elm), field); \ 575 else { \ 576 (head)->tqh_last = &TAILQ_NEXT((elm), field); \ 577 QMD_TRACE_HEAD(head); \ 578 } \ 579 TAILQ_NEXT((listelm), field) = (elm); \ 580 (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \ 581 QMD_TRACE_ELEM(&(elm)->field); \ 582 QMD_TRACE_ELEM(&listelm->field); \ 583 } while (0) 584 585 #define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ 586 (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ 587 TAILQ_NEXT((elm), field) = (listelm); \ 588 *(listelm)->field.tqe_prev = (elm); \ 589 (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \ 590 QMD_TRACE_ELEM(&(elm)->field); \ 591 QMD_TRACE_ELEM(&listelm->field); \ 592 } while (0) 593 594 #define TAILQ_INSERT_HEAD(head, elm, field) do { \ 595 if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \ 596 TAILQ_FIRST((head))->field.tqe_prev = \ 597 &TAILQ_NEXT((elm), field); \ 598 else \ 599 (head)->tqh_last = &TAILQ_NEXT((elm), field); \ 600 TAILQ_FIRST((head)) = (elm); \ 601 (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \ 602 QMD_TRACE_HEAD(head); \ 603 QMD_TRACE_ELEM(&(elm)->field); \ 604 } while (0) 605 606 #define TAILQ_INSERT_TAIL(head, elm, field) do { \ 607 TAILQ_NEXT((elm), field) = NULL; \ 608 (elm)->field.tqe_prev = (head)->tqh_last; \ 609 *(head)->tqh_last = (elm); \ 610 (head)->tqh_last = &TAILQ_NEXT((elm), field); \ 611 QMD_TRACE_HEAD(head); \ 612 QMD_TRACE_ELEM(&(elm)->field); \ 613 } while (0) 614 615 #define TAILQ_LAST(head, headname) \ 616 (*(((struct headname *)((head)->tqh_last))->tqh_last)) 617 618 #define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) 619 620 #define TAILQ_PREV(elm, headname, field) \ 621 (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) 622 623 #define TAILQ_REMOVE(head, elm, field) do { \ 624 if ((TAILQ_NEXT((elm), field)) != NULL) \ 625 TAILQ_NEXT((elm), field)->field.tqe_prev = \ 626 (elm)->field.tqe_prev; \ 627 else { \ 628 (head)->tqh_last = (elm)->field.tqe_prev; \ 629 QMD_TRACE_HEAD(head); \ 630 } \ 631 *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \ 632 TRASHIT((elm)->field.tqe_next); \ 633 TRASHIT((elm)->field.tqe_prev); \ 634 QMD_TRACE_ELEM(&(elm)->field); \ 635 } while (0) 636 637 #endif -
trunk/ithildin/include/ithildin/socket.h
r787 r798 37 37 38 38 struct isocket { 39 CALLBACK_SAFE; 40 39 41 int fd; /* file descriptor */ 40 42 #ifdef HAVE_OPENSSL -
trunk/ithildin/lib/SConscript
r790 r798 16 16 # Build specification for the ithildin library 17 17 env.Install(env['libdir'], 18 env.SharedLibrary(target = 'ithildin', source = Split(''' 19 conf.c 20 event.c 21 global.c 22 hash.c 23 log.c 24 malloc.c 25 md5.c 26 module.c 27 socket.c 28 string.c 29 timer.c 30 util.c 31 ''') 18 env.SharedLibrary(target = 'ithildin', 19 source = Split(''' 20 conf.c event.c global.c hash.c log.c malloc.c md5.c module.c socket.c string.c 21 timer.c util.c 22 '''), 23 CPPDEFINES = env['CPPDEFINES'] + Split(r''' 24 SHLIBPREFIX="\"%s\"" 25 SHLIBSUFFIX="\"%s\"" 26 ''' % (env['SHLIBPREFIX'], env['SHLIBSUFFIX'])) 32 27 ) 33 28 ) -
trunk/ithildin/lib/module.c
r787 r798 18 18 #endif 19 19 20 /* filename extension for modules, will become variable when multiple21 * platforms become supported. */22 #define MODULE_EXTENSION ".so"23 24 20 /* create a module structure. */ 25 21 static module_t *add_module_from_config(conf_entry_t *); 26 22 static module_t *create_module(char *); 27 23 static void destroy_module(module_t *); 24 static bool load_module_deps(module_t *, char **, int, bool); 28 25 29 26 /* this is called both at start-up and at any time when the conf is reloaded … … 61 58 /* now load modules which requested autoloading. we do this here instead 62 59 * of above so we can read in all the module data before we load 63 * anything. very handy, incidentally, modules are loaded in reverse 64 * order from the file. hopefully that won't matter to anyone :) */ 60 * anything. */ 65 61 LIST_FOREACH(m, &me.modules, lp) { 66 62 if (m->flags & MODULE_FL_AUTOLOAD && !(m->flags & MODULE_FL_LOADED)) … … 182 178 int load_module(char *name, int flags) { 183 179 module_t *m = NULL; 184 /* neverask for explicit symbol resolution. every library a module180 /* always ask for explicit symbol resolution. every library a module 185 181 * depends on should be *already linked against* the module in question. 186 182 * we do not provide symbol help (because it is not reliably … … 248 244 return 0; 249 245 } 250 251 deplist = (char **)dlsym(m->handle, "mdepends");252 246 253 247 sn = strrchr(m->name, '/'); … … 288 282 m->flags |= MODULE_FL_LOADED | flags; 289 283 290 while (deplist != NULL && *deplist != NULL) { 291 module_t *m2 = find_module(*deplist); 292 if (m2 == NULL || !(m2->flags & MODULE_FL_DEPENDLOAD)) { 293 if (m2 == NULL) 294 log_notice("loading dependant module %s for %s", *deplist, name); 295 if (!load_module(*deplist, flags | MODULE_FL_DEPENDLOAD | 296 MODULE_FL_CREATE | MODULE_FL_QUIET)) { 297 log_error("loading dependant failed, giving up for %s!", name); 298 unload_module(m->name); 299 return 0; 300 } 301 m2 = find_module(*deplist); 302 } 303 /* m2 now definitely exists (yay) */ 304 mdep = malloc(sizeof(struct module_dependency)); 305 mdep->mod = m; 306 LIST_INSERT_HEAD(&m2->deps, mdep, lp); 307 deplist++; /* and onto the next one */ 308 } 309 284 if ((deplist = (char **)dlsym(m->handle, "mdepends")) != NULL) { 285 if (!load_module_deps(m, deplist, flags, true)) { 286 unload_module(m->name); 287 return 0; 288 } 289 } 290 if ((deplist = (char **)dlsym(m->handle, "msoftdepends")) != NULL) { 291 if (!load_module_deps(m, deplist, flags, false)) 292 log_warn("some soft dependencies for %s failed to load, " 293 "continuing anyway.", m->name); 294 } 310 295 311 296 /* okay, hopefully this will stay here. I've decided to hook the … … 353 338 354 339 return 1; 340 } 341 342 static bool load_module_deps(module_t *m, char **deplist, int flags, 343 bool hardfail) { 344 module_t *m2; 345 bool allok = true; 346 struct module_dependency *mdep; 347 348 while (deplist != NULL && *deplist != NULL) { 349 m2 = find_module(*deplist); 350 if (m2 == NULL || !(m2->flags & MODULE_FL_DEPENDLOAD)) { 351 if (m2 == NULL) 352 log_notice("loading dependant module %s for %s", *deplist, 353 m->name); 354 if (!load_module(*deplist, flags | MODULE_FL_DEPENDLOAD | 355 MODULE_FL_CREATE | MODULE_FL_QUIET)) { 356 if (hardfail == true) 357 return false; 358 else 359 allok = false; 360 } 361 m2 = find_module(*deplist); 362 } 363 deplist++; /* move on to next module */ 364 365 if (hardfail) { 366 /* m2 is guaranteed in this case */ 367 mdep = malloc(sizeof(struct module_dependency)); 368 mdep->mod = m; 369 LIST_INSERT_HEAD(&m2->deps, mdep, lp); 370 } else 371 continue; /* do not link soft dependencies */ 372 } 373 374 return allok; 355 375 } 356 376 … … 547 567 m->fullpath = malloc(PATH_MAX); 548 568 m->name = strdup(name); 549 /* strip off the extension */ 550 if (MODULE_EXTENSION[0]) { 551 s = strrchr(m->name, MODULE_EXTENSION[0]); 569 570 /* strip off the prefix and suffix, if they exist. */ 571 if (SHLIBPREFIX[0]) { 572 size_t pfxlen = strlen(SHLIBPREFIX); 573 size_t namelen = strlen(m->name); 574 if (!strncasecmp(m->name, SHLIBPREFIX, pfxlen)) { 575 memmove(m->name, m->name + pfxlen, namelen - pfxlen); 576 m->name[namelen - pfxlen] = '\0'; 577 } 578 } 579 if (SHLIBSUFFIX[0]) { 580 s = strrchr(m->name, SHLIBSUFFIX[0]); 552 581 if (s != NULL) { 553 if (!strcmp(s, MODULE_EXTENSION))582 if (!strcmp(s, SHLIBSUFFIX)) 554 583 *s = '\0'; 555 584 } 556 585 } 557 586 558 sprintf(m->fullpath, "%s/%s" MODULE_EXTENSION, me.lib_path, m->name); 587 sprintf(m->fullpath, "%s/%s%s%s", me.lib_path, SHLIBPREFIX, m->name, 588 SHLIBSUFFIX); 559 589 if (access(m->fullpath, R_OK | X_OK) == -1) { 560 590 log_error("unable to open module %s from %s: %s", m->name, -
trunk/ithildin/lib/socket.c
r787 r798 172 172 173 173 /* we only close the socket and mark it as dead, we reap dead sockets after 174 * the polling phase. see reap_dead_sockets() */ 174 * the polling phase. see reap_dead_sockets(). That said we do go 175 * ahead and cancel all callbacks for the socket immediately. */ 176 callback_cancel(sock); 175 177 close_socket(sock); 176 178 sock->state |= SOCKET_FL_DEAD;
Note: See TracChangeset
for help on using the changeset viewer.
