schedule_t * New_Schedule (char *description, trace_t *tr) { schedule_t *schedule; schedule = New (schedule_t); schedule->ll_events = LL_Create (LL_DestroyFunction, Deref_Event, 0); if (description == NULL) description = strdup ("unknown"); schedule->description = strdup (description); /* this trace condition is delegated from the caller */ schedule->trace = tr; schedule->lastrun = 0; schedule->maxnum = 0; schedule->is_running = 0; schedule->can_pass = 0; #ifdef HAVE_LIBPTHREAD pthread_cond_init (&schedule->cond_new_event, NULL); #endif /* HAVE_LIBPTHREAD */ pthread_mutex_init (&schedule->mutex_cond_lock, NULL); pthread_mutex_init (&schedule->mutex_lock, NULL); pthread_mutex_lock (&SCHEDULE_MASTER->mutex_lock); LL_Add (SCHEDULE_MASTER->ll_schedules, schedule); pthread_mutex_unlock (&SCHEDULE_MASTER->mutex_lock); return (schedule); }
// --------------------------------------------------------------- //a therad which asynchronously save th registry entries // --------------------------------------------------------------- void AsyncSaveKeyBckgProc (void *param) { struct S_ini *pmsg; LL_Create (LL_ID_SETTINGS, 500); tThreads[TH_ASYNCSAVEKEY].bInit = TRUE; // inits OK do { WaitForSingleObject (tThreads[TH_ASYNCSAVEKEY].hEv, INFINITE); Sleep (10); for ( pmsg = LL_PopMsg (LL_ID_SETTINGS); pmsg != NULL ; pmsg = LL_PopMsg (LL_ID_SETTINGS) ) { SaveKey (pmsg->path, pmsg->key, pmsg->buf, pmsg->bufsize, pmsg->type, pmsg->inifile); DeleteMsg(pmsg); } ResetEvent ( tThreads[TH_ASYNCSAVEKEY].hEv ); } while ( tThreads[TH_ASYNCSAVEKEY].gRunning ); LL_Destroy (LL_ID_SETTINGS); LogToMonitor ("end of registry thread\n"); _endthread (); } // AsyncSaveKeyProc
int init_object () { OBJECT_MASTER = New (object_master_t); OBJECT_MASTER->ll_objects = LL_Create (NULL); return (1); }
int init_schedules (trace_t *tr) { assert (SCHEDULE_MASTER == NULL); SCHEDULE_MASTER = New (schedule_master_t); SCHEDULE_MASTER->ll_schedules = LL_Create (0); SCHEDULE_MASTER->trace = tr; pthread_mutex_init (&SCHEDULE_MASTER->mutex_lock, NULL); return (1); }
/* pick_off_secondary_fields * store some information like as_origin, communities, * and secondary indicie keys * Need some error checking added --ljb XXX */ void pick_off_secondary_fields (char *buffer, int curr_f, irr_object_t *irr_object) { char *cp = buffer; char *tmpptr; switch (curr_f) { case ORIGIN: /* if origin already found, ignore continuation lines */ if (irr_object->origin_found) break; whitespace_newline_remove(cp); cp += 2; /* Check for dots for now, can remove as asplain is standardized */ if ( (tmpptr = strchr(cp,'.')) != NULL) { *tmpptr = 0; irr_object->origin = atoi(cp)*65536 + atoi(tmpptr + 1); *tmpptr = '.'; irr_object->origin_found = 1; } else { if (convert_to_32(cp, &irr_object->origin) != 1) { irr_object->origin = 0; /* bogus value, need better handling */ } else irr_object->origin_found = 1; } break; case NIC_HDL: whitespace_newline_remove(cp); irr_object->nic_hdl = strdup (cp); break; case PREFIX: /* for IPv6 site objects */ if (irr_object->ll_prefix == NULL) /* create list if it does not exist */ irr_object->ll_prefix = LL_Create (LL_DestroyFunction, free, 0); whitespace_newline_remove(cp); LL_Add (irr_object->ll_prefix, strdup(cp)); break; case MNT_BY: add_field_items (cp, &irr_object->ll_mnt_by); break; case MEMBER_OF: /* ROUTE, ROUTE6 and AUT-NUM member-of: scanning */ add_field_items (cp, &irr_object->ll_mbr_of); break; case MEMBERS: case MP_MEMBERS: /* AS-SET, ROUTE-SET members: scanning */ add_field_items (cp, &irr_object->ll_mbrs); break; case MBRS_BY_REF: /* AS-SET, ROUTE-SET mbrs-by-ref: scanning */ add_field_items (cp, &irr_object->ll_mbr_by_ref); break; default: break; } }
void testInsert() { Node *head = LL_Create( 4 ); LL_Insert( &head, 2, compare_ints ); LL_Insert( &head, 8, compare_ints ); assert( head -> data == 2 ); LL_Insert_Front( &head, 1 ); print_list( head ); assert( head -> data == 1 ); }
void add_field_items (char *buf, LINKED_LIST **ll) { char *cp = buf, *last; if (*ll == NULL) /* create list if it does not exist */ *ll = LL_Create (LL_DestroyFunction, free, 0); whitespace_newline_remove (cp); strtok_r (cp, ",", &last); while (cp != NULL && *cp != '\0') { whitespace_remove (cp); /* sanity check */ if (*cp != '\0') LL_Add ((*ll), strdup (cp)); cp = strtok_r (NULL, ",", &last); } }
/*----------------------------------------------------------- * Name: HASH_ToLinkedList() * Created: Fri Sep 9 00:01:14 1994 * Author: Jonathan DeKock <dekock@winter> * DESCR: converts a hash table to a linked list */ LINKED_LIST *HASH_ToLinkedList(HASH_TABLE *h, LINKED_LIST *ll) { unsigned index; #ifdef HASH_DEBUG if (!h) { if (HASH_Handler) { (HASH_Handler)(h, HASH_BadArgument, "HASH_ToLinkedList()"); } } #endif if (!ll) ll = LL_Create(0); if (h->attr & HASH_Intrusive) { DATA_PTR data; for (index = 0; index < h->size; index++) { for (data = h->array.data[index]; data; data = NextP(h, data)) { LL_Add(ll, data); } } } else { HASH_CONTAINER *cont; for (index = 0; index < h->size; index++) { for (cont = h->array.cont[index]; cont; cont = cont->next) { LL_Add(ll, cont->data); } } } #ifdef HASH_DEBUG if (h->attr & HASH_ReportAccess) { printf("HASH TABLE: 0x%.8x ToLinkedList(0x%.8x) complete\n", h, ll); } #endif #ifdef _HASH_INTERNAL_DEBUG HASH_Verify(h); #endif return(ll); }
int add_access_list (int num, int permit, prefix_t *prefix, prefix_t *wildcard, int exact, int refine) { condition_t *condition = NULL; if (num < 0 || num >= MAX_ALIST) return (-1); if (find_access_list (num, permit, prefix, wildcard, exact, refine)) return (0); if (access_list[num] == NULL) { access_list[num] = LL_Create (0); } condition = irrd_malloc(sizeof(condition_t)); condition->permit = permit; /* expects Ref_Prefix can handle even a case of prefix == NULL */ condition->prefix = Ref_Prefix (prefix); condition->wildcard = Ref_Prefix (wildcard); condition->exact = exact; condition->refine = refine; LL_Add (access_list[num], condition); return (LL_GetCount (access_list[num])); }
// init : just create the msg file and pass some arguments // for the LOG function void StartAsyncMessagingFacility (void) { LL_Create (LL_ID_MSG_TO_GUI, MAX_MSG_IN_QUEUE); } // StartAsyncMessagingFacility
/* as-set/route-set expansion !ias-bar */ void irr_set_expand (irr_connection_t *irr, char *name) { irr_database_t *database; time_t start_time; GArray *array; GQueue *stack; GHashTable *hash_member_examined; member_examined_hash_t *member_examined_ptr; LINKED_LIST *ll_setlist; char *set_name, *last_set_name, *mstr, *db; char *range_op, abuf[BUFSIZE]; char *lasts = NULL; int i, first, dup, expand_flag = NO_EXPAND; hash_spec_t *hash_spec; if (strchr(name, ',') != NULL) { strtok_r(name, ",", &lasts); /* check if we are expanding a route-set */ if ( (set_name = strchr(name, ':')) != NULL) set_name++; else set_name = name; if (!strncasecmp (set_name, "rs-", 3)) expand_flag = ROUTE_SET_EXPAND; else expand_flag = OTHER_EXPAND; } start_time = time(NULL); convert_toupper (name); stack = g_queue_new(); hash_member_examined = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, (GDestroyNotify)HashMemberExaminedDestroy); ll_setlist = LL_Create (LL_DestroyFunction, free, NULL); mstr = rpsl_macro_expand_add (" ", name, irr, NULL); g_queue_push_head(stack, mstr); member_examined_ptr = irrd_malloc(sizeof(member_examined_hash_t)); member_examined_ptr->key = strdup(name); g_hash_table_insert(hash_member_examined, member_examined_ptr->key, member_examined_ptr); while (!g_queue_is_empty(stack)) { if ( IRR.expansion_timeout > 0 ) { if ( (time(NULL) - start_time) > IRR.expansion_timeout ) { trace (ERROR, default_trace, "irr_set_expand(): Set expansion timeout\n"); sprintf(abuf, "Expansion maximum CPU time exceeded: %d seconds", IRR.expansion_timeout); irr_send_error(irr, abuf); goto getout; } } mstr = (char *) g_queue_pop_head(stack); /* might want to check the examined list to see if this set name has been examined already */ first = 1; lasts = NULL; range_op = strtok_r (mstr, ",", &lasts); if (!strcmp (range_op, " ")) range_op = NULL; set_name = strtok_r (NULL, ",", &lasts); irr_lock_all(irr); /* lock db's while searching */ while ((db = strtok_r (NULL, ",", &lasts)) != NULL) { if ((database = find_database (db)) == NULL) { trace (ERROR, default_trace, "irr_set_expand(): Database not found %s\n", db); sprintf(abuf, "Database not found: %s", db); irr_send_error(irr, abuf); goto getout; } make_setobj_key (abuf, set_name); if ((hash_spec = fetch_hash_spec (database, abuf, UNPACK)) != NULL) { first = 0; update_members_list (database, range_op, AF_INET, expand_flag, hash_member_examined, ll_setlist, hash_spec->ll_1, stack, irr); mbrs_by_ref_set (database, range_op, AF_INET, expand_flag, ll_setlist, set_name, hash_spec->ll_2, irr); Delete_hash_spec (hash_spec); } if (first == 0) break; } irr_unlock_all(irr); free (mstr); } first = 1; dup = 0; i = 0; last_set_name = ""; array = g_array_sized_new(FALSE, TRUE, sizeof(char*), ll_setlist->count); LL_ContIterate (ll_setlist, set_name) { g_array_append_val(array, set_name); }
static void read_ascii (FILE *fd, io_t *IO) { LINKED_LIST *ll_ann, *ll_with; bgp_attr_t *attr; int announce_flag = 0; int line_num = 0; int have_data = 0; int have_data2 = 0; time_t tstamp = 0; int type = 0; int subtype = 0; int bgptype = 0; int newtype = 0; gateway_t *gateway_from = NULL; gateway_t *gateway_to = NULL; int first = 1; u_char bgp_packet[BGPMAXPACKETSIZE], *bp = bgp_packet; u_char buffer[MAX_MSG_SIZE], *buffer_p = buffer; u_char *end = buffer + sizeof (buffer); int eof = 0; buffer_t *stdbuf; int state1 = 0, state2 = 0; int version = 0, as = 0, holdtime = 0, optlen = 0; u_long id = 0; int code = 0, subcode = 0; int viewno = 0; char *filename = NULL; prefix_t *route_prefix = NULL; time_t originated = 0; u_long status = 0; int seq_num = 0; attr = bgp_new_attr (PROTO_BGP); ll_ann = LL_Create (LL_DestroyFunction, Deref_Prefix, 0); ll_with = LL_Create (LL_DestroyFunction, Deref_Prefix, 0); stdbuf = New_Buffer_Stream (fd); for (;;) { char *line = NULL, *ret = NULL; int len = 0; int ok = 0; char *cp; if (buffer_gets (stdbuf) <= 0) { eof++; } else { len = buffer_data_len (stdbuf); line = buffer_data (stdbuf); if (line[len - 1] == '\n') { line[len - 1] = '\0'; len--; } trace (TR_TRACE, MRT->trace, "++%s\n", line); line_num++; if ((cp = strpbrk (line, "#!")) != NULL) { *cp = '\0'; len = cp - line; } if (first && nulline (line)) continue; first = 0; } if (eof || nulline (line)) { if (have_data && have_data2) { trace (TR_ERROR, MRT->trace, "Mixture of two formats\n"); goto error; } if (bgptype == BGP_UPDATE && have_data) { flushout (IO, tstamp, type, subtype, attr, ll_ann, ll_with, gateway_to); } else if (have_data2) { flushout2 (IO, tstamp, type, subtype, bgp_packet, bp - bgp_packet, gateway_from, gateway_to); } else if (bgptype == BGP_KEEPALIVE) { if (type == MSG_PROTOCOL_BGP4MP) { memset (bgp_packet, 0xff, BGP_HEADER_MARKER_LEN); BGP_PUT_HDRTYPE (bgptype, bgp_packet); bp = bgp_packet + BGP_HEADER_LEN; BGP_PUT_HDRLEN (bp - bgp_packet, bgp_packet); } else { bp = bgp_packet; } flushout2 (IO, tstamp, type, subtype, bgp_packet, bp - bgp_packet, gateway_from, gateway_to); } else if (bgptype == BGP_OPEN) { if (type == MSG_PROTOCOL_BGP4MP) { memset (bgp_packet, 0xff, BGP_HEADER_MARKER_LEN); BGP_PUT_HDRTYPE (bgptype, bgp_packet); bp = bgp_packet + BGP_HEADER_LEN; } else { bp = bgp_packet; } BGP_PUT_BYTE (version, bp); BGP_PUT_SHORT (as, bp); BGP_PUT_SHORT (holdtime, bp); BGP_PUT_NETLONG (id, bp); BGP_PUT_BYTE (0, bp); /* XXX */ if (type == MSG_PROTOCOL_BGP4MP) { BGP_PUT_HDRLEN (bp - bgp_packet, bgp_packet); } flushout2 (IO, tstamp, type, subtype, bgp_packet, bp - bgp_packet, gateway_from, gateway_to); } else if (bgptype == BGP_NOTIFY) { if (type == MSG_PROTOCOL_BGP4MP) { memset (bgp_packet, 0xff, BGP_HEADER_MARKER_LEN); BGP_PUT_HDRTYPE (bgptype, bgp_packet); bp = bgp_packet + BGP_HEADER_LEN; } else { bp = bgp_packet; } BGP_PUT_BYTE (code, bp); BGP_PUT_BYTE (subcode, bp); if (type == MSG_PROTOCOL_BGP4MP) { BGP_PUT_HDRLEN (bp - bgp_packet, bgp_packet); } flushout2 (IO, tstamp, type, subtype, bgp_packet, bp - bgp_packet, gateway_from, gateway_to); } else if (newtype == BGP4MP_STATE_CHANGE) { bp = bgp_packet; BGP_PUT_SHORT (state1, bp); BGP_PUT_SHORT (state2, bp); flushout2 (IO, tstamp, type, subtype, bgp_packet, bp - bgp_packet, gateway_from, NULL); } else if (newtype == BGP4MP_SNAPSHOT) { bp = bgp_packet; BGP_PUT_SHORT (viewno, bp); if (filename) BGP_PUT_DATA (filename, strlen (filename), bp); BGP_PUT_BYTE (0, bp); trace_mrt_header (MRT->trace, tstamp, type, subtype); io_write (IO, tstamp, type, subtype, bp - bgp_packet, bgp_packet); } else if (newtype == BGP4MP_ENTRY) { if (route_prefix != NULL) { buffer_p = bgp_table_dump_entry (buffer_p, end, type, subtype, viewno, route_prefix, status, originated, attr); } if (buffer_p - buffer > 0) { trace_mrt_header (MRT->trace, tstamp, type, subtype); io_write (IO, tstamp, type, subtype, buffer_p - buffer, buffer); } } if (eof) break; if (MRT->force_exit_flag) exit (1); bgp_deref_attr (attr); attr = bgp_new_attr (PROTO_BGP); LL_Clear (ll_ann); LL_Clear (ll_with); announce_flag = 0; have_data = 0; have_data2 = 0; tstamp = 0; type = 0; subtype = 0; bgptype = 0; newtype = 0; gateway_to = NULL; gateway_from = NULL; route_prefix = NULL; seq_num = 0; first = 1; if (filename) free (filename); filename = NULL; continue; } if (have_data) { /* a prefix -- line begins with a space */ if (isspace (line[0])) { prefix_t *prefix; char *cp = line +1; while (isspace (*cp)) cp++; if ((prefix = ascii2prefix (0, cp)) != NULL) { if (announce_flag == 1) { LL_Add (ll_ann, prefix); } else { LL_Add (ll_with, prefix); } continue; } } } if (have_data2) { prefix_t *prefix; int num; u_long value; if (isspace (line[0]) && strpbrk (line, ".:") && strchr (line, '/') && parse_line (line, "%d %m", &num, &prefix) == 2) { u_char *here = bp; /* v4 or v6 address with prefixlen */ #ifdef HAVE_IPV6 if (prefix->family == AF_INET6) BGP_PUT_PREFIX6 (prefix->bitlen, prefix_tochar (prefix), bp); else #endif /* HAVE_IPV6 */ BGP_PUT_PREFIX (prefix->bitlen, prefix_tochar (prefix), bp); Deref_Prefix (prefix); if (num != bp - here) { trace (TR_ERROR, MRT->trace, "length was %d but must be %d\n", num, bp - here); goto error; } continue; } else if (isspace (line[0]) && strpbrk (line, ".:") && parse_line (line, "%d %M", &num, &prefix) == 2) { /* v4 or v6 address w/o prefixlen */ if (prefix->family == AF_INET6 && num > 16) { trace (TR_ERROR, MRT->trace, "length was %d but must be less than or equal %d\n", num, 16); Deref_Prefix (prefix); goto error; } if (prefix->family == AF_INET && num > 4) { trace (TR_ERROR, MRT->trace, "length was %d but must be less than or equal %d\n", num, 4); Deref_Prefix (prefix); goto error; } BGP_PUT_DATA (prefix_tochar (prefix), num, bp); Deref_Prefix (prefix); continue; } else if (isspace (line[0]) && parse_line (line, "%d %i", &num, &value) == 2) { if (num == 1) BGP_PUT_BYTE (value, bp); else if (num == 2) BGP_PUT_SHORT (value, bp); else if (num == 4) BGP_PUT_LONG (value, bp); else { trace (TR_ERROR, MRT->trace, "unknown length %d\n", num); goto error; } continue; } } if ((ret = checkstradvance (line, "TIME"))) { struct tm tm; if (strptime (ret, "%D %T", &tm)) { time_t now; time (&now); tm.tm_isdst = localtime (&now)->tm_isdst; adjust_y2k (&tm); tstamp = mktime (&tm); } } else if ((ret = checkstradvance (line, "TO"))) { int as; char data[MAXLINE]; prefix_t *prefix; if (sscanf (ret, "%s AS%d", data, &as) >= 2 || sscanf (ret, "AS%d %s", &as, data) >= 2 /* obsolete */) { prefix = ascii2prefix (0, data); gateway_to = add_gateway (prefix, as, NULL); Deref_Prefix (prefix); } } else if ((ret = checkstradvance (line, "FROM"))) { int as; char data[MAXLINE]; if (sscanf (ret, "%s AS%d", data, &as) >= 2 || sscanf (ret, "AS%d %s", &as, data) >= 2 /* obsolete */) { prefix_t *prefix = ascii2prefix (0, data); gateway_from = add_gateway (prefix, as, NULL); attr->gateway = gateway_from; Deref_Prefix (prefix); } } /* type BGP/UPDATE */ else if ((ret = checkstradvance (line, "TYPE"))) { char *subtypestr; char **cpp; int i; if ((subtypestr = strchr (ret, '/')) != NULL) *subtypestr++ = '\0'; cpp = S_MRT_MSG_TYPES; for (i = 0; cpp[i]; i++) { if (strcasecmp (cpp[i], ret) == 0) break; } type = (enum MRT_MSG_TYPES) i; if (subtypestr) { char *subsubtypestr; if ((subsubtypestr = strchr (subtypestr, '/')) != NULL) *subsubtypestr++ = '\0'; if ((cpp = S_MRT_MSG_SUBTYPES[type]) != NULL) { for (i = 0; cpp[i]; i++) { if (strcasecmp (cpp[i], subtypestr) == 0) break; } subtype = i; } newtype = subtype; if (type == MSG_PROTOCOL_BGP || type == MSG_PROTOCOL_BGP4PLUS || type == MSG_PROTOCOL_BGP4PLUS_01) { if (subtype == MSG_BGP_UPDATE) { bgptype = BGP_UPDATE; newtype = BGP4MP_MESSAGE; } else if (subtype == MSG_BGP_KEEPALIVE) { bgptype = BGP_KEEPALIVE; newtype = BGP4MP_MESSAGE; } else if (subtype == MSG_BGP_NOTIFY) { bgptype = BGP_NOTIFY; newtype = BGP4MP_MESSAGE; } else if (subtype == MSG_BGP_OPEN) { bgptype = BGP_OPEN; newtype = BGP4MP_MESSAGE; } else if (subtype == MSG_BGP_SYNC) { newtype = BGP4MP_SNAPSHOT; } else if (subtype == MSG_BGP_STATE_CHANGE) { newtype = BGP4MP_STATE_CHANGE; } else if (subtype == MSG_TABLE_DUMP) { newtype = BGP4MP_ENTRY; } } else if (type == MSG_PROTOCOL_BGP4MP && ( subtype == BGP4MP_MESSAGE || subtype == BGP4MP_MESSAGE_OLD)) { for (i = 0; sbgp_pdus[i]; i++) { if (strcasecmp (sbgp_pdus[i], subsubtypestr) == 0) { bgptype = i; break; } } } } if (type == MSG_PROTOCOL_BGP || type == MSG_PROTOCOL_BGP4PLUS || type == MSG_PROTOCOL_BGP4PLUS_01 || type == MSG_TABLE_DUMP || type == MSG_PROTOCOL_BGP4MP ) { /* OK */ } else { trace (TR_ERROR, MRT->trace, "Unknown message type %s at line %d\n", ret, line_num); goto error; } } else if ((ret = checkstradvance (line, "DATA"))) { bp = bgp_packet; have_data2++; } else if (newtype == BGP4MP_STATE_CHANGE && (ret = checkstradvance (line, "PEER"))) { int as; char data[MAXLINE]; if (sscanf (ret, "%s AS%d", data, &as) >= 2 || sscanf (ret, "AS%d %s", &as, data) >= 2 /* obsolete */) { prefix_t *prefix = ascii2prefix (0, data); gateway_from = add_gateway (prefix, as, NULL); Deref_Prefix (prefix); } } else if (newtype == BGP4MP_STATE_CHANGE && (ret = checkstradvance (line, "STATE"))) { char *cp = strchr (ret, '/'); int i; if (cp == NULL) goto error; *cp++ = '\0'; for (i = 0; sbgp_states[i]; i++) { if (strcasecmp (sbgp_states[i], ret) == 0) { state1 = i; } } for (i = 0; sbgp_states[i]; i++) { if (strcasecmp (sbgp_states[i], cp) == 0) { state2 = i; } } } else if ((newtype == BGP4MP_SNAPSHOT || newtype == BGP4MP_ENTRY) && (ret = checkstradvance (line, "VIEW"))) { viewno = atoi (ret); } else if (newtype == BGP4MP_SNAPSHOT && (ret = checkstradvance (line, "FILE"))) { if (filename) free (filename); filename = strdup (ret); } else if (newtype == BGP4MP_ENTRY && (ret = checkstradvance (line, "PREFIX"))) { if (route_prefix == NULL) { buffer_p = buffer; if (type == MSG_TABLE_DUMP) { BGP_PUT_SHORT (viewno, buffer_p); BGP_PUT_SHORT (seq_num, buffer_p); } } else { buffer_p = bgp_table_dump_entry (buffer_p, end, type, subtype, viewno, route_prefix, status, originated, attr); } route_prefix = ascii2prefix (0, ret); bgp_deref_attr (attr); attr = bgp_new_attr (PROTO_BGP); } else if (newtype == BGP4MP_ENTRY && (ret = checkstradvance (line, "SEQUENCE"))) { seq_num = atoi (ret); } else if (newtype == BGP4MP_ENTRY && (ret = checkstradvance (line, "ORIGINATED"))) { struct tm tm; if (strptime (ret, "%D %T", &tm)) { time_t now; time (&now); tm.tm_isdst = localtime (&now)->tm_isdst; adjust_y2k (&tm); originated = mktime (&tm); } } else if (newtype == BGP4MP_ENTRY && (ret = checkstradvance (line, "STATUS"))) { sscanf (ret, "%li", &status); } else if (bgptype == BGP_OPEN && (ret = checkstradvance (line, "VERSION"))) { version = atoi (ret); } else if (bgptype == BGP_OPEN && (ret = checkstradvance (line, "AS"))) { as = atoi (ret); } else if (bgptype == BGP_OPEN && (ret = checkstradvance (line, "HOLD_TIME"))) { holdtime = atoi (ret); } else if (bgptype == BGP_OPEN && (ret = checkstradvance (line, "ID"))) { inet_pton (AF_INET, ret, &id); } else if (bgptype == BGP_OPEN && (ret = checkstradvance (line, "OPT_PARM_LEN"))) { optlen = atoi (ret); } else if (bgptype == BGP_NOTIFY && (ret = checkstradvance (line, "CODE"))) { char *cp; code = atoi (ret); if ((cp = strchr (ret, '/')) != NULL) subcode = atoi (cp + 1); } else if (bgptype == BGP_UPDATE && (ret = checkstradvance (line, "ANNOUNCE"))) { announce_flag = 1; have_data++; } else if (bgptype == BGP_UPDATE && (ret = checkstradvance (line, "WITHDRAW"))) { announce_flag = 0; have_data++; } else if ((bgptype == BGP_UPDATE || newtype == BGP4MP_ENTRY) && (ok = bgp_scan_attr (line, attr, MRT->trace)) > 0) { /* OK */ } else if ((bgptype == BGP_UPDATE || newtype == BGP4MP_ENTRY) && ok < 0) { trace (TR_ERROR, MRT->trace, "Invalid BGP attribute at line %d\n", line_num); goto error; } else { trace (TR_ERROR, MRT->trace, "Unrecognized line at %d\n", line_num); goto error; } } error: if (filename) free (filename); bgp_deref_attr (attr); LL_Destroy (ll_ann); LL_Destroy (ll_with); Delete_Buffer (stdbuf); }
if (precedence < 0) precedence = 0; if (ll_route_map[num]) { LL_Iterate (ll_route_map[num], route_map) { if (route_map->precedence == precedence) { route_map->flag = flag; return (route_map); } if (route_map->precedence > precedence) break; prev = route_map; } } else { ll_route_map[num] = LL_Create (LL_DestroyFunction, del_route_map_memory, 0); } route_map = New (route_map_t); route_map->attr = bgp_new_attr (PROTO_BGP); route_map->flag = flag; /* XXX condition */ route_map->alist = -1; route_map->flist = -1; route_map->clist = -1; route_map->precedence = precedence; LL_InsertAfter (ll_route_map[num], route_map, prev); return (route_map); } int
void testCreate() { Node *head = LL_Create( 4 ); assert( head -> data == 4 ); assert( head -> next == NULL ); }