예제 #1
0
파일: main.c 프로젝트: zyxstar/exam_c
int main(void)
{
	struct score tmp, *p;
	LLIST *list;
	int i;

	list = llist_creat(sizeof(struct score));
	/* if error */

	for (i = 0; i < 9; i++) {
		tmp.id = i;
		tmp.ch = 100 - i;
		tmp.math = 100 - i * 2;
		tmp.en = 100 - i * 3;
		snprintf(tmp.name, NAMESIZE, "stu%d", i);

		llist_add(list, &tmp, LLIST_ADD_FORWARD);
	}

	llist_travel(list, print_score);
	llist_delet(list, "stu6", name_cmp);
	printf("\n");
	llist_travel(list, print_score);
#if 0
	p = llist_find(list, "stuxx", name_cmp);
	if (p == NULL) {
		printf("Can not find.\n");
	} else {
		print_score(p);
	}
#endif

	llist_destroy(list);
	return 0;
}
예제 #2
0
파일: main.c 프로젝트: wcybxzj/shangguan
//变长结构体版本
//类的概念:数据和方法都放入头节点
int main(int argc, const char *argv[])
{
	int i, ret;
	LLIST *handler;
	SCORE_ST tmp, *tmp_p;
	handler = llist_creat(sizeof(SCORE_ST));

	for (i = 0; i < 7; i++) {
		tmp.id = i;
		snprintf(tmp.name, NAMESIZE, "middle school student%d", i);
		tmp.math = rand() %100;
		tmp.chinese = rand() %100;
		//myprint(&tmp);
		llist_insert(handler, &tmp, LLIST_FORWARD);
	}

	llist_travel(handler, myprint);

	printf("-----------------------------------\n");

	char *name = "stu3";
	tmp_p = llist_find(handler, name, cmp_name);
	if (tmp_p) {
		myprint(tmp_p);
	}else{
		printf("not find\n");
	}

	printf("-----------------------------------\n");
	int id = 2;
	ret = llist_fetch(handler, &id, cmp_id, &tmp);
	if (ret) {
		printf("fetch ");
		myprint(&tmp);
	}

	printf("-----------------------------------\n");
	name ="stu0";
	ret = llist_delete(handler, name, cmp_name);
	if (ret) {
		printf("delete %s\n", name);
	}
	printf("-----------------------------------\n");
	llist_travel(handler, myprint);
	printf("-----------------------------------\n");

	name = malloc(NAMESIZE);
	for (i = 1; i < 7; i++) {
		snprintf(name, NAMESIZE, "stu%d", i);
		ret = llist_delete(handler, name, cmp_name);
		if (ret) {
			printf("delete %s\n", name);
		}
	}
	llist_travel(handler, myprint);

	llist_destroy(handler);
	return 0;
}
예제 #3
0
파일: main.c 프로젝트: zyxstar/exam_c
int main(void)
{

      struct score tmp, *datap;
      int i, id;
      LLIST *list;
      int ret;

      list = llist_creat(sizeof(struct score));

      for (i = 0; i < 7; i++) {
	    tmp.id = i;
	    tmp.math = 100 - i;
	    snprintf(tmp.name, NAMESIZE, "stu%d", i);

	    llist_insert(list, &tmp, LLIST_BACKWARD);
      }

      llist_travel(list, print_s);

      id = 4;
      ret = llist_fetch(list, &tmp, &id, id_cmp);
      printf("\n");
      if (ret == -1) {
	    printf("Can not find.\n");
      } else {
	    print_s(&tmp);
      }
      printf("\n");
      llist_travel(list, print_s);

#if 0
      id = 8;
      llist_delet(list, &id, id_cmp);
      printf("\n");
      llist_travel(list, print_s);
      id = 2;
      datap = llist_find(list, &id, id_cmp);
      if (datap == NULL) {
	    printf("Can not find.\n");
      } else {
	    print_s(datap);
      }
#endif
      llist_save(list, "stu.data");

      llist_destroy(list);

      LLIST *list2 = llist_load("stu.data");
      llist_travel(list2, print_s);
      llist_destroy(list2);
      

      return 0;
}
예제 #4
0
파일: schan_members.c 프로젝트: asksven/irc
static void schan_members_rename(struct llist_header *head, char *oldnick, char *newnick)
{
	struct stats_member *m;

	m = llist_find(head, (void *)oldnick);
	if (!m)
		return;
	Assert(newnick);
	m->nick = nrealloc(m->nick, strlen(newnick) + 1);
	strcpy(m->nick, newnick);
}
예제 #5
0
파일: main.c 프로젝트: harkhuang/harkcode
int main()
{
	struct score tmp,*datap;
	int i,id,ret;
	char name[] = "sstu1";
	LLIST *handle;

	handle = llist_create(sizeof(struct score));
	if(handle == NULL)
		return -1;

	for(i = 0; i < 6 ;i++)
	{
		tmp.id = i;
		tmp.math = 100-i;
		snprintf(tmp.name,NAMESIZE,"stu%d",i);

		llist_insert(handle,&tmp,LLIST_BACKWARD);
		
	}
	
	llist_travel(handle,print_s);
	printf("\n\n");
	id = 3;

	ret = llist_fetch(handle,&id,id_cmp,&tmp);
	if(ret != -1)
		print_s(&tmp);
	printf("\n\n");
	llist_travel(handle,print_s);

	llist_destroy(handle);

//	llist_delete(handle,&id,id_cmp);
//	llist_travel(handle,print_s);


#if 0	
//	datap = llist_find(handle,&id,id_cmp);
	datap = llist_find(handle,name,name_cmp);
	if(datap == NULL)
		printf("can not find!\n");
	else
		print_s(datap);
#endif


	return 0;
}
예제 #6
0
void pwospf_hello_type(struct ip* ip_header, byte* payload, uint16_t payload_len, pwospf_header_t* pwospf_header, interface_t* intf) {
   printf(" ** pwospf_hello_type(..) called \n");
   printf(" ** pwospf_hello_type(..) packet with length: %u \n", payload_len);
   // make hello packet
   pwospf_hello_packet_t* hello_packet = (pwospf_hello_packet_t*) malloc_or_die(sizeof(pwospf_hello_packet_t));
   memcpy(&hello_packet->network_mask, payload, 4);
   memcpy(&hello_packet->helloint, payload + 4, 2);
   memcpy(&hello_packet->padding, payload + 6, 2);
   // display packet
   printf(" ** pwospf_hello_type(..) displayed header contents:\n");
   display_hello_packet(hello_packet);
   // check mask and hello interval
   if(intf->subnet_mask == hello_packet->network_mask && intf->helloint == ntohs(hello_packet->helloint)) {
      printf(" ** pwospf_hello_type(..) network mask and hello interval correct\n");
      // if the interface has no neighbors
      if(intf->neighbor_list == NULL) {
         printf(" ** pwospf_hello_type(..) interface has no neighbors, adding new neighbor\n");
         add_neighbor(intf, pwospf_header->router_id, ip_header->ip_src.s_addr, hello_packet->helloint, hello_packet->network_mask);
      } else { // interface has existing neighbors
         // generate neighbor object
         neighbor_t* neighbor = make_neighbor(pwospf_header->router_id, ip_header->ip_src.s_addr, hello_packet->helloint, hello_packet->network_mask);
         // get last instance so that lsu info can be put back
         pthread_mutex_lock(&intf->neighbor_lock);
         node* ret = llist_find( intf->neighbor_list, predicate_id_neighbor_t,(void*) &pwospf_header->router_id);
         pthread_mutex_unlock(&intf->neighbor_lock);
         if( ret!= NULL) {
            neighbor_t *neighbor_ret = (neighbor_t*) ret->data;
            neighbor->last_adverts = neighbor_ret->last_adverts;
            neighbor->last_lsu_packet = neighbor_ret->last_lsu_packet;
         }
         // lock neighbor list
         pthread_mutex_lock(&intf->neighbor_lock);
         // if exists, then update, otherwise add
         intf->neighbor_list = llist_update_beginning_delete(intf->neighbor_list, predicate_neighbor_t, (void*) neighbor);
         pthread_mutex_unlock(&intf->neighbor_lock);
      }
      // update info in neighbor db
      // get instance of router 
      struct sr_instance* sr_inst = get_sr();
      struct sr_router* router = (struct sr_router*)sr_get_subsystem(sr_inst);
      update_neighbor_vertex_t_rid(router, ip_header->ip_src.s_addr, pwospf_header->router_id);
   } else {
      printf(" ** pwospf_hello_type(..) network mask or hello interval incorrect\n");
   }
}
예제 #7
0
파일: main.c 프로젝트: zyxstar/exam_c
int main(void)
{
	LLIST *llist;
	struct score tmp, *datap;
	int i;
	int id;
	struct sum_st sum = {0,0};

	llist = llist_creat(sizeof(struct score));
	/* if error */

	for (i = 0; i < 7; i++) {
		tmp.id = i;
		snprintf(tmp.name, NAMESIZE, "stu%d", i);
		tmp.ch = 100 - i;
		tmp.math = 100 - 2 * i;

		llist_insert(llist, &tmp);
		/* if error */
	}

	llist_travel(llist, print_score, NULL);
	printf("\n");

#if 1
	id = 3;
	llist_delet(llist, &id, id_cmp);
	llist_travel(llist, print_score, NULL);
#else
	datap = llist_find(llist, &id, id_cmp);
	if (datap == NULL) {
		printf("Can not find.\n");
	} else {
		print_score(datap, NULL);
	}
	llist_travel(llist, get_sum, &sum);
	printf("sum: ch = %d, math = %d\n", sum.ch, sum.math);
#endif

	llist_destroy(llist);

	return 0;
}
예제 #8
0
int main()
{
	LLIST *handle;
	int i ,ret, id = 3;
    char *name = "person2";
	struct person_st tmp, *datap;
	
	handle = llist_create(sizeof(struct person_st));
	if(handle== NULL)
		return -1;
	
	for(i = 0; i < 6; i++)
	{
		tmp.id = i;
		tmp.age = 20 + i;
		snprintf(tmp.name,NAMESIZE,"person%d",i);
		
		llist_insert(handle,&tmp,LLIST_FORWARD);
	}
	
	llist_travel(handle,print_s);
	printf("\n\n");

    ret =  llist_fetch(handle,name,name_cmp,&tmp);
    if(ret == 0)
        print_s(&tmp);
    printf("\n\n");
   
  //  llist_delete(handle,&id,id_cmp);
  //  llist_travel(handle,print_s);

#if 0
    //datap = llist_find(handle,&id,id_cmp);
    datap = llist_find(handle,name,name_cmp);
        if(datap == NULL)
            printf("ca not find!\n");
        else
            print_s(datap);
#endif
	llist_destroy(handle);
	return 0;
}
예제 #9
0
void pwospf_lsu_type(struct ip* ip_header, byte* payload, uint16_t payload_len, pwospf_header_t* pwospf_header, interface_t* intf) {
   printf(" ** pwospf_lsu_type(..) called \n");
   printf(" ** pwospf_lsu_type(..) packet with length: %u \n", payload_len);
   struct sr_instance* sr_inst = get_sr();
   struct sr_router* router = (struct sr_router*)sr_get_subsystem(sr_inst);
   // make lsu packet
   pwospf_lsu_packet_t* lsu_packet = (pwospf_lsu_packet_t*) malloc_or_die(sizeof(pwospf_lsu_packet_t));
   memcpy(&lsu_packet->seq, payload, 2);
   memcpy(&lsu_packet->ttl, payload + 2, 2);
   memcpy(&lsu_packet->no_of_adverts, payload + 4, 4);
   // display packet
   printf(" ** pwospf_lsu_type(..) displayed header contents:\n");
   display_lsu_packet(lsu_packet);
   // calculate number of adverts
   int num_adverts = ((payload_len - 8)/sizeof(pwospf_ls_advert_t));
   printf(" ** pwospf_lsu_type(..) number of adverts: %d\n", num_adverts);
   // check if I generated the LSU
   if(pwospf_header->router_id != intf->router_id) {
      // not generated by self
      // check if neighbor ever sent hello packet
       pthread_mutex_lock(&intf->neighbor_lock);
       node* ret = llist_find( intf->neighbor_list, predicate_id_neighbor_t,(void*) &pwospf_header->router_id);
       pthread_mutex_unlock(&intf->neighbor_lock);
       if(ret != NULL) {
       // have received a hello packet from this neighbor in the recent past
          neighbor_t *neighbor = (neighbor_t*) ret->data;
          display_neighbor_t((void*) neighbor);
          // check if lsu received for first time
          if(neighbor->last_adverts == NULL) {
             printf(" ** pwospf_lsu_type(..) first lsu received from this neighbor\n");
             neighbor->last_lsu_packet = *lsu_packet;
             neighbor->last_adverts = (byte*) malloc_or_die(payload_len - 8);
             memcpy(neighbor->last_adverts, payload + 8, payload_len - 8);
             // add to list
             pthread_mutex_lock(&intf->neighbor_lock);  
             intf->neighbor_list = llist_update_beginning_delete(intf->neighbor_list, predicate_id_neighbor_t_neighbor_t, (void*) neighbor);
             pthread_mutex_unlock(&intf->neighbor_lock);
             display_neighbor_t((void*) neighbor);
             // create router entry
             router_entry_t router_entry;
             router_entry.router_id = neighbor->id;
             router_entry.area_id = 0;
             //add vertex with router entry info
             add_neighbor_vertex_t(router, router_entry);
             //create subnet entry
             subnet_entry_t* subnet_entry;
             //add adverts to db
             printf(" ** pwospf_lsu_type(..) adding adverts to neighbor db\n");
             int i;
             pwospf_ls_advert_t* ls_advert = (pwospf_ls_advert_t*) malloc_or_die(sizeof(pwospf_ls_advert_t));
             for(i = 0; i < ntohl(lsu_packet->no_of_adverts) ; i++) {
                memcpy(&ls_advert->subnet, payload + sizeof(pwospf_lsu_packet_t) + sizeof(pwospf_ls_advert_t) * i, 4);         
                memcpy(&ls_advert->mask, payload + sizeof(pwospf_lsu_packet_t) + 4 + sizeof(pwospf_ls_advert_t) * i, 4);
                memcpy(&ls_advert->router_id, payload + sizeof(pwospf_lsu_packet_t) + 8 + sizeof(pwospf_ls_advert_t) * i, 4);
                display_ls_advert(ls_advert);
                subnet_entry = create_subnet_entry_t_advert(ls_advert);
                add_subnet_entry_t(router, router_entry, subnet_entry);
             }
             // update vertices
             update_neighbor_vertex_t(router, router_entry);
             //calculate new routing table via Dijkstra
             calculate_routing_table(router);
             //check if route/multipath is enabled
             if(router->reroute_multipath_status == TRUE) {
                //run multipath
                reroute_multipath(router);
             }
             //dijkstra2(router); 
             //free(lsu_packet);
             //free(ret);
             //free(neighbor);
             //free(ls_advert);
          } else {
          // check if the previous seq was same
          if(neighbor->last_lsu_packet.seq != lsu_packet->seq) {
             // nope, new seq
             neighbor->last_lsu_packet = *lsu_packet;
             // flood to all neighbors
             pwospf_flood_lsu(ip_header, pwospf_header, lsu_packet, neighbor, intf);
             // check if content the same
             printf("last adverts :%s\n",  (char*) neighbor->last_adverts);
             printf("new: %s\n", (char*) (payload + 8));
             if(memcmp(neighbor->last_adverts, payload + 8, payload_len - 8) != 0) {
                // nope new content
                printf(" ** pwospf_lsu_type(..) new content neighbor db\n");
                if(ntohl(neighbor->last_lsu_packet.no_of_adverts) != ntohl(lsu_packet->no_of_adverts)) {
                   // free mem, as new adverts might need different memory
                   free(neighbor->last_adverts);
                   // now allocate new mem space
                   neighbor->last_adverts = (byte*) malloc_or_die(payload_len - 8);
                }
                memcpy(neighbor->last_adverts, payload + 8, payload_len - 8);
                neighbor->last_lsu_packet = *lsu_packet;
                // update packet info in neighbor list
                pthread_mutex_lock(&intf->neighbor_lock);
                intf->neighbor_list = llist_update_beginning_delete(intf->neighbor_list, predicate_id_neighbor_t_neighbor_t, (void*) neighbor);
                pthread_mutex_unlock(&intf->neighbor_lock);
                // check if entry exists in DB
                // create router entry
                router_entry_t router_entry;
                router_entry.router_id = neighbor->id;
                router_entry.area_id = 0;
                //refresh vertex with router entry info, clear previous subnets
                refresh_neighbor_vertex_t(router, router_entry);
               //create subnet entry
                subnet_entry_t* subnet_entry;

             	int i;
             	pwospf_ls_advert_t* ls_advert = (pwospf_ls_advert_t*) malloc_or_die(sizeof(pwospf_ls_advert_t));
             	if(check_neighbor_vertex_t_router_entry_t_id(router, neighbor->id) == 1) {
                   printf(" ** pwospf_lsu_type(..) neighbor already known, checking if any new adverts\n");
                   //neighbor present in db, check if any new adverts
                   for(i = 0; i < ntohl(lsu_packet->no_of_adverts) ; i++) {
                      memcpy(&ls_advert->subnet, payload + sizeof(pwospf_lsu_packet_t) + sizeof(pwospf_ls_advert_t) * i, 4);
                      memcpy(&ls_advert->mask, payload + sizeof(pwospf_lsu_packet_t) + 4
 + sizeof(pwospf_ls_advert_t) * i, 4);
                      memcpy(&ls_advert->router_id, payload + sizeof(pwospf_lsu_packet_t) + 8 + sizeof(pwospf_ls_advert_t) * i, 4);
                         display_ls_advert(ls_advert);
                         subnet_entry = create_subnet_entry_t_advert(ls_advert);
                	 add_subnet_entry_t(router, router_entry, subnet_entry);
                   }    
                   // update vertices
             	   update_neighbor_vertex_t(router, router_entry);
                } 
                  //run Djikstra's algo to calculate new routing table
                  calculate_routing_table(router);
                  //check if route/multipath is enabled
                  if(router->reroute_multipath_status == TRUE) {
                     //run multipath
                     reroute_multipath(router);
                  }
                  //dijkstra2(router);
                } else {
                     printf(" ** pwospf_lsu_type(..) error, content same as previous from this neighbor, only updating time stamp in DB\n");  
                     // update timestamp
                     // create router entry
	             router_entry_t router_entry;
                     router_entry.router_id = neighbor->id;
                     router_entry.area_id = 0;
                     update_neighbor_vertex_t_timestamp(router, router_entry);

             }
          } else {
              printf(" ** pwospf_lsu_type(..) error, seq same as previous one from this neighbor, dropping\n");
          }
       }
       } else {
          printf(" ** pwospf_lsu_type(..) error, neighbor hasn't said hello recently, dropping\n");
       }
   } else {
      //drop packet
      printf(" ** pwospf_lsu_type(..) error, LSU generated by self. dropping\n");
      //free stuff
     free(lsu_packet);
   } 
}
예제 #10
0
파일: schan_members.c 프로젝트: asksven/irc
static struct stats_member *schan_members_find(struct llist_header *head, char *nick)
{
	return llist_find(head, (void *)nick);
}
예제 #11
0
파일: oper.c 프로젝트: Korrigan/irc
t_oper *find_oper(t_operlist **l, t_oper *m, t_oper_cmp cmp)
{
  return ((t_oper *)llist_find((t_llist **)l, (void *)m, (t_llist_cmp)cmp));
}
예제 #12
0
파일: test_int.c 프로젝트: kissthink/notes
int main(void)
{
    int n, ret;
    void *ret1;
    LLIST *handle = NULL;
    LLIST *find = NULL;
    
    handle = llist_create(sizeof(int), NULL, NULL, NULL);

    while (1)
    {
        printf("please input num : ");
        scanf("%d", &n);

        if (n == -1)
            break;

        llist_insert(&n, APPEND, handle);
    }
    
    llist_travel(printf_s, NULL, handle);
    printf("\n");

    printf("insert num : ");
    scanf("%d", &n);
    llist_insert(&n, 3, handle);
    llist_travel(printf_s, NULL, handle);
    printf("\n");

    printf("delete num : ");
    scanf("%d", &n);
    llist_delete(&n, cmp, handle);
    llist_travel(printf_s, NULL, handle);
    printf("\n");

	printf("find num : ");
	scanf("%d", &n);
	ret1 = llist_find(&n, cmp, handle);
    if(ret1 != NULL)
        printf("find = %d\n", *(int*)ret1);
    printf("\n");

    printf("findall num : ");
    scanf("%d", &n);
    find = llist_findall(&n, cmp, handle);
    llist_travel(printf_s, find, handle);
    printf("\n");

    llist_sort(cmp, handle);
    printf("sort:");
    llist_travel(printf_s, NULL, handle);
	printf("\n");

    ret = llist_store("./db", handle);
    if(ret == 0)
        printf("存储成功!\n");

    llist_destroy(&handle);

    return 0;
}