1 | /*************************************** 2 | $Revision: 1.15 $ 3 | 4 | UP module utilities 5 | 6 | Status: REVIEWED, NOT TESTED 7 | 8 | Author(s): Engin Gunduz 9 | 10 | ******************/ /****************** 11 | Modification History: 12 | engin (17/01/2000) Created. 13 | denis (31/08/2001) Modified for new API 14 | ******************/ /****************** 15 | Copyright (c) 2000,2001,2002 RIPE NCC 16 | 17 | All Rights Reserved 18 | 19 | Permission to use, copy, modify, and distribute this software and its 20 | documentation for any purpose and without fee is hereby granted, 21 | provided that the above copyright notice appear in all copies and that 22 | both that copyright notice and this permission notice appear in 23 | supporting documentation, and that the name of the author not be 24 | used in advertising or publicity pertaining to distribution of the 25 | software without specific, written prior permission. 26 | 27 | THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING 28 | ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL 29 | AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY 30 | DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN 31 | AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 32 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 33 | ***************************************/ 34 | 35 | #include <time.h> 36 | #include "dbupdate.h" 37 | #include "UP_extrnl_syntax.h" 38 | #include "ud.h" 39 | #include "notification.h" 40 | 41 | extern int tracing; 42 | extern char * overridecryptedpw; 43 | extern int test_mode; 44 | extern char * updlog; 45 | extern char * update_host; 46 | extern int update_port; 47 | extern char * query_host; 48 | extern int query_port; 49 | extern char * humailbox; 50 | extern char * autobox; 51 | extern char * netupdclientIP; 52 | 53 | extern int reading_from_mail; 54 | extern int networkupdate; 55 | 56 | 57 | extern char *update_mail_sender; 58 | extern char *update_mail_subject; 59 | extern char *update_mail_date; 60 | extern char *update_mail_ID; 61 | extern char *update_mail_cc; 62 | 63 | extern char *header_type; 64 | extern char *text_type; 65 | 66 | extern char *DBhost; 67 | extern int DBport; 68 | extern char *DBuser; 69 | extern char *DBname; 70 | extern char *DBpasswd; 71 | 72 | 73 | /* authorise function takes the auth_vector, credentials struct, and 'overriden' 74 | variable. If overriden == 1, then it immediately returns UP_AUTH_OK 75 | (because this means that the update contained a valid override attribute). 76 | Else, it goes through the auth_vector and when it finds a an "auth:" 77 | attribute which passes, then it returns UP_AUTH_OK. Otherwise, it returns 78 | UP_AUF (authorisation failed) */ 79 | 80 | int authorise(GSList * auth_vector, credentials_struct credentials, int overriden) 81 | { 82 | int result = 0; 83 | 84 | if (tracing) 85 | { 86 | printf("TRACING: authorise started with override: %i\n", overriden); 87 | } 88 | 89 | /* If 'overriden' variable is 1, then return UP_AUTH_OK immediately */ 90 | if (overriden == 1) 91 | { 92 | return UP_AUTH_OK; 93 | } 94 | else 95 | { 96 | result = AU_authorise(auth_vector, credentials); 97 | if (tracing) 98 | { 99 | printf("TRACING: authorise: AU_authorise returned %i\n", result); 100 | } 101 | if (result > 0) 102 | { 103 | return UP_AUTH_OK; 104 | } 105 | else 106 | { 107 | return UP_AUF; /* authorisation failed */ 108 | } 109 | } 110 | } 111 | 112 | 113 | 114 | /* interprets the result string coming from RIPupd 115 | It is called by send_object_db. 116 | It returns the error no returned from RIPupd. */ 117 | 118 | int interpret_ripdb_result(const char * string) 119 | { 120 | char * error_no = NULL; 121 | char ** temp = NULL, ** temp2 = NULL; 122 | int i; 123 | int err = 0; 124 | 125 | /* if the string is NULL or empty, then return error */ 126 | if (string == NULL || strlen(string) == 0) 127 | { 128 | return 0; 129 | } 130 | 131 | /* split the string into lines */ 132 | temp = g_strsplit(string , "\n", 0); 133 | for (i = 0; temp[i] != NULL; i++) 134 | { 135 | if (i == 0) 136 | { /* this line must contain "%ERROR " string in the beginning */ 137 | temp2 = g_strsplit(temp[0], " ", 0); 138 | error_no = strdup(temp2[1]); 139 | g_strfreev(temp2); 140 | err = atoi(error_no); 141 | if (tracing) 142 | { 143 | printf("TRACING: interpret_ripdb_result: error_no is [%s]\n", error_no); 144 | } 145 | } 146 | else if (error_no != NULL && strcmp(error_no, "0") != 0) 147 | { 148 | } 149 | } 150 | g_strfreev(temp); 151 | if (error_no != NULL) 152 | { 153 | free(error_no); 154 | } 155 | return err; /* 0 means no error in this context */ 156 | } 157 | 158 | 159 | 160 | /* Gets assigned NIC hdl from the string that is returned from 161 | RIPupdate */ 162 | void get_assigned_nic(char * nic_hdl, const char * string) 163 | { 164 | char * error_no = NULL; 165 | char ** temp = NULL, ** temp2 = NULL; 166 | int i; 167 | 168 | if (tracing) 169 | { 170 | printf("TRACING: get_assigned_nic is running\n"); 171 | } 172 | 173 | /* if the string is NULL or empty, then return error */ 174 | if (string == NULL || strlen(string) == 0) 175 | { 176 | return; 177 | } 178 | 179 | /* split the string into lines */ 180 | temp = g_strsplit(string , "\n", 0); 181 | for (i = 0; temp[i] != NULL; i++) 182 | { 183 | if (i == 0) 184 | { /* this line must contain "%ERROR " string in the beginning */ 185 | temp2 = g_strsplit(temp[0], " ", 0); 186 | error_no = strdup(temp2[1]); 187 | g_strfreev(temp2); 188 | if (tracing) 189 | { 190 | printf("TRACING: get_assigned_nic: error_no is [%s]\n", error_no); 191 | } 192 | } 193 | else if (error_no != NULL && strcmp(error_no, "0") != 0) 194 | { 195 | } 196 | else if (error_no != NULL && strcmp(error_no, "0") == 0 && i == 1) 197 | { /* look for assigned NIC hdl */ 198 | /* in the second line RIPupdate returns for example "I[65][EK3-RIPE]" We 199 | need to extract EK3-RIPE part */ 200 | nic_hdl = strncpy(nic_hdl, rindex(temp[i],'[') + 1 , 201 | rindex(temp[i],']') - rindex(temp[i],'[') - 1); 202 | nic_hdl[rindex(temp[i],']') - rindex(temp[i],'[') - 1] = '\0'; 203 | if (tracing && nic_hdl != NULL) 204 | { 205 | printf("TRACING: get_assigned_nic will return [%s]\n", nic_hdl); 206 | } 207 | g_strfreev(temp); 208 | return; 209 | } 210 | } 211 | g_strfreev(temp); 212 | return; 213 | } 214 | 215 | 216 | 217 | /* Obtains a transaction ID for an object. Will be called from send_object_db */ 218 | int up_get_transaction_id() 219 | { 220 | SQ_connection_t * sql_connection; 221 | SQ_result_set_t *result; 222 | int error; 223 | long new_id; 224 | 225 | sql_connection = SQ_get_connection(DBhost, DBport, DBname, DBuser, DBpasswd); 226 | if (!sql_connection) 227 | { 228 | fprintf(stderr, "No SQL connection\n"); 229 | exit(1); 230 | } 231 | error = SQ_execute_query(sql_connection, "INSERT INTO tid VALUES(NULL)", &result); 232 | if (error) 233 | { 234 | fprintf(stderr,"ERROR: %s\n", SQ_error(sql_connection)); 235 | exit(1); 236 | } 237 | 238 | new_id = mysql_insert_id(sql_connection); 239 | 240 | SQ_close_connection(sql_connection); 241 | 242 | return new_id; 243 | } 244 | 245 | 246 | 247 | /* sends the object to the database. char * operation is either 'ADD' ,'DEL' or 'UPD' 248 | assigned_NIC is filled in if this is a person/role creation with AUTO nic hdl 249 | assigned_NIC must be allocated enough memory before send_object_db is called 250 | 251 | If the called do not expect a NIC hdl back, then assigned_NIC can be given NULL 252 | */ 253 | up_ripupd_result_struct * send_object_db(rpsl_object_t *object, char * assigned_NIC, char * operation) 254 | { 255 | int sockfd, numbytes; 256 | char buf[MAXDATASIZE + 1]; 257 | struct hostent *he; 258 | struct sockaddr_in their_addr; /* connector's address information */ 259 | char *result_string = NULL; 260 | int err = 0; 261 | char *to_be_sent = NULL; 262 | int tr_id; 263 | char * tr_id_str; 264 | char * tempstr; 265 | rpsl_object_t *sent_object; 266 | rpsl_attr_t *removed_attr; 267 | rpsl_error_t return_error; 268 | 269 | up_ripupd_result_struct * return_struct; 270 | 271 | if (tracing) 272 | { 273 | printf("TRACING: send_object_db is running: assigned_NIC : [%s]; operation: [%s]\n", assigned_NIC ? assigned_NIC : "", operation); 274 | } 275 | return_struct = (up_ripupd_result_struct *)malloc(sizeof(up_ripupd_result_struct)); 276 | return_struct->error_str = NULL; 277 | 278 | /* copy the object, remove the override password and create a text string */ 279 | sent_object = rpsl_object_copy(object); 280 | removed_attr = rpsl_object_remove_attr_name(sent_object,"override",&return_error); 281 | to_be_sent = rpsl_object_get_text(sent_object,0); 282 | rpsl_object_delete(sent_object); 283 | 284 | if (tracing) 285 | { 286 | printf("TRACING: send_object_db: to_be_sent : [\n%s]\n", to_be_sent); 287 | } 288 | 289 | /* get the transaction ID, to be sent to RIPupdate*/ 290 | tr_id = up_get_transaction_id(); 291 | 292 | /* convert it into a string */ 293 | tr_id_str = (char *)malloc(64); 294 | sprintf(tr_id_str, "%d", tr_id); 295 | 296 | if (tracing) 297 | { 298 | printf("TRACING: send_object_db: tr_id_str : [%s]\n", tr_id_str); 299 | } 300 | 301 | if ((he=gethostbyname(update_host)) == NULL) 302 | { /* get the host info */ 303 | perror("gethostbyname"); 304 | exit(1); 305 | } 306 | 307 | if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) 308 | { 309 | perror("socket"); 310 | exit(1); 311 | } 312 | 313 | their_addr.sin_family = AF_INET; /* host byte order */ 314 | their_addr.sin_port = htons(update_port); /* short, network byte order */ 315 | their_addr.sin_addr = *((struct in_addr *)he->h_addr); 316 | bzero(&(their_addr.sin_zero), 8); /* zero the rest of the struct */ 317 | 318 | 319 | if (connect(sockfd, (struct sockaddr *)&their_addr, 320 | sizeof(struct sockaddr)) == -1) 321 | { 322 | perror("connect"); 323 | exit(1); 324 | } 325 | 326 | if (send(sockfd, operation , strlen(operation), 0) == -1) 327 | perror("send"); 328 | if (send(sockfd, " ", strlen(" "), 0) == -1) 329 | perror("send"); 330 | if (send(sockfd, tr_id_str, strlen(tr_id_str), 0) == -1) 331 | perror("send"); 332 | if (send(sockfd, "\n\n" , strlen("\n\n"), 0) == -1) 333 | perror("send"); 334 | if (send(sockfd, to_be_sent, strlen(to_be_sent), 0) == -1) 335 | perror("send"); 336 | if (send(sockfd, "\n\n", 2, 0) == -1) 337 | perror("send"); 338 | /* send the ACK now */ 339 | if (send(sockfd, "ACK ",strlen("ACK "), 0) == -1) 340 | perror("send"); 341 | if (send(sockfd, tr_id_str, strlen(tr_id_str), 0) == -1) 342 | perror("send"); 343 | if (send(sockfd, "\n\n",strlen("\n\n"), 0) == -1) 344 | perror("send"); 345 | 346 | if (tracing) 347 | { 348 | printf("TRACING: send_object_db: send complete\n"); 349 | } 350 | 351 | 352 | while ((numbytes=recv(sockfd, buf, MAXDATASIZE, 0)) != 0) 353 | { 354 | buf[numbytes] = '\0'; 355 | if (tracing) 356 | { 357 | printf("received from socket [\n%s]\n",buf); 358 | } 359 | if (result_string == NULL) 360 | { 361 | result_string = strdup(buf); 362 | } 363 | else 364 | { 365 | result_string = (char *)realloc(result_string, 366 | strlen(result_string) + strlen(buf) + 1); 367 | result_string = strcat(result_string, buf); 368 | } 369 | if (strstr(result_string,"\n\n") != NULL) 370 | { /* if the result_string contains 371 | an empty line at the end, we will close */ 372 | break; 373 | }; 374 | } 375 | 376 | free(tr_id_str); 377 | err = interpret_ripdb_result(result_string); 378 | 379 | if (tracing) 380 | { 381 | printf("TRACING: send_object_db: interpret_ripdb_result returned : [%i]\n", err); 382 | } 383 | 384 | if (assigned_NIC != NULL) 385 | { /* if the caller of the function expected to get a NIC handle */ 386 | get_assigned_nic(assigned_NIC, result_string); 387 | } 388 | close(sockfd); 389 | free(to_be_sent); 390 | return_struct->result = err; 391 | 392 | /*return_struct->error_str = strdup(result_string); */ 393 | /* According to the error no got from RIPupdate, construct an error string */ 394 | switch (return_struct->result) 395 | { 396 | case 0: break; 397 | case ERROR_U_MEM: 398 | case ERROR_U_DBS: 399 | case ERROR_U_BADOP: 400 | case ERROR_U_COP: 401 | case ERROR_U_NSUP: 402 | case ERROR_U_BUG: 403 | tempstr = (char *)malloc(1024); 404 | snprintf(tempstr, 1024, "***Error: Please contact database admin: Error no %i", 405 | return_struct->result); 406 | return_struct->error_str = tempstr; 407 | break; 408 | case ERROR_U_OBJ: 409 | printf("\nresult_string [%s]\n\n", result_string); 410 | tempstr = (char *)malloc(1024); 411 | /* if the object contains refs to unknown objects */ 412 | if (strstr(result_string, "dummy") != NULL || 413 | strstr(result_string, "reference cannot be resolved") != NULL ) 414 | { 415 | /* if the response from RIPupd contains "dummy not allowed" string 416 | or a reference that cannot be resolved */ 417 | snprintf(tempstr, 1024, "***Error: Unknown object referenced"); 418 | } 419 | else if (strstr(result_string, "key-cert") != NULL) 420 | { 421 | /* if the response from RIPupd contains "no key-cert object" string */ 422 | snprintf(tempstr, 1024, "***Error: Unknown key-cert object referenced"); 423 | } 424 | else 425 | { 426 | /* then, the object is referenced from other objects */ 427 | snprintf(tempstr, 1024, "***Error: Object is referenced from other objects"); 428 | } 429 | return_struct->error_str = tempstr; 430 | break; 431 | case ERROR_U_AUT: 432 | tempstr = (char *)malloc(1024); 433 | snprintf(tempstr, 1024, "***Error: Membership authorisation failure"); 434 | return_struct->error_str = tempstr; 435 | break; 436 | default: 437 | tempstr = (char *)malloc(1024); 438 | snprintf(tempstr, 1024, "***Error: Please contact database admin: Error no %i", 439 | return_struct->result); 440 | return_struct->error_str = tempstr; 441 | break; 442 | } 443 | return return_struct; 444 | } 445 | 446 | 447 | 448 | /* takes an object (pre-parsed) and returns its first attrib if it is not 449 | a person/role, and returns the nic-hdl if it is a person/role object */ 450 | char * get_search_key(rpsl_object_t *object, const char * type) 451 | { 452 | char *primary_key = NULL; 453 | char *lctype; 454 | GList *attr_list; 455 | 456 | if(object == NULL) return NULL; 457 | 458 | lctype = strdup(type); 459 | g_strdown(lctype); 460 | if ( strcmp(lctype, "person") == 0 || strcmp(lctype, "role") == 0 ) 461 | { 462 | /* this is a person or role object */ 463 | /* get the nic-hdl attribute */ 464 | attr_list = rpsl_object_get_attr(object, "nic-hdl"); 465 | } 466 | else 467 | { 468 | /* this is NOT a person or role object */ 469 | /* get the class attribute */ 470 | attr_list = rpsl_object_get_attr(object, type); 471 | } 472 | 473 | if ( attr_list ) 474 | { 475 | primary_key = rpsl_attr_get_clean_value((rpsl_attr_t *)(attr_list->data)); 476 | } 477 | free(lctype); 478 | return primary_key ; 479 | } 480 | 481 | 482 | 483 | /* sends char * arg to the specified host's specified port, and 484 | returns the reply as a string. This is used to query the 485 | whois host. Probably we must use WC (whois client) module here, 486 | but it must be extented */ 487 | char * send_and_get(char * host, int port, char * arg) 488 | { 489 | int sockfd, numbytes; 490 | char * result = NULL; 491 | char buf[MAXDATASIZE + 1]; 492 | struct hostent *he; 493 | struct sockaddr_in their_addr; /* connector's address information */ 494 | 495 | if(tracing) 496 | { 497 | printf("TRACING: send_and_get: arg : [%s]; port: [%i]; host: [%s]\n", arg, port, host); 498 | } 499 | 500 | if ((he=gethostbyname(host)) == NULL) 501 | { /* get the host info */ 502 | perror("gethostbyname"); 503 | exit(1); 504 | } 505 | 506 | if(tracing) 507 | { 508 | printf("TRACING: send_and_get: called gethostbyname\n"); 509 | } 510 | 511 | if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) 512 | { 513 | perror("socket"); 514 | exit(1); 515 | } 516 | 517 | if(tracing) 518 | { 519 | printf("TRACING: send_and_get: called socket\n"); 520 | } 521 | 522 | their_addr.sin_family = AF_INET; /* host byte order */ 523 | their_addr.sin_port = htons(port); /* short, network byte order */ 524 | their_addr.sin_addr = *((struct in_addr *)he->h_addr); 525 | bzero(&(their_addr.sin_zero), 8); /* zero the rest of the struct */ 526 | 527 | if (connect(sockfd, (struct sockaddr *)&their_addr, 528 | sizeof(struct sockaddr)) == -1) 529 | { 530 | perror("connect"); 531 | exit(1); 532 | } 533 | if (send(sockfd, arg , strlen(arg), 0) == -1) 534 | perror("send"); 535 | if (send(sockfd, "\n",1,0) == -1) 536 | perror("send"); 537 | 538 | while ((numbytes=recv(sockfd, buf, MAXDATASIZE, 0)) != 0) 539 | { 540 | buf[numbytes] = '\0'; 541 | if (result == NULL) 542 | { 543 | result = strdup(buf); 544 | } 545 | else 546 | { 547 | result = (char *)realloc(result, strlen(result) + strlen(buf) + 1); 548 | result = strcat(result, buf); 549 | } 550 | } 551 | 552 | close(sockfd); 553 | return result; 554 | } 555 | 556 | 557 | 558 | /* counts the number of objects in a string */ 559 | int count_objects(char * arg) 560 | { 561 | int count = 0; 562 | char *pos = NULL; 563 | char *temp = NULL; 564 | 565 | if(tracing) 566 | { 567 | printf("TRACING: count_objects running\n"); 568 | } 569 | 570 | if(arg != NULL) 571 | { 572 | temp = strdup(arg); 573 | } 574 | else 575 | { 576 | return 0; 577 | } 578 | 579 | if ( isalpha( (int)(arg[0]) ) ) 580 | { 581 | count++; 582 | } 583 | else if (arg[0] == '\n' && isalpha( (int)(arg[1]) ) ) 584 | { 585 | count++; 586 | } 587 | while ( (pos = strstr(temp,"\n\n")) ) 588 | { 589 | pos[0] = 'a'; /* something non-EOL so that it won't be caught in the next loop */ 590 | if ( isalpha( (int)(pos[2]) ) ) 591 | { 592 | count++; 593 | } 594 | } 595 | if(tracing) 596 | { 597 | printf("TRACING: count_objects returning %d\n", count); 598 | } 599 | free(temp); 600 | return count; 601 | } 602 | 603 | 604 | 605 | /* strips lines beginning with '%' off */ 606 | char * strip_lines(char * arg) 607 | { 608 | char ** temp = NULL; 609 | char * string = NULL; 610 | int i; 611 | 612 | if (arg == NULL) 613 | { 614 | return NULL; 615 | } 616 | 617 | /* split the string into lines */ 618 | temp = g_strsplit (arg, "\n", 0); 619 | 620 | for (i=0; temp[i] != NULL; i++) 621 | { 622 | if (temp[i][0] != '%') 623 | { 624 | if (string == NULL) 625 | { 626 | string = strdup(temp[i]); 627 | } 628 | else 629 | { 630 | string = (char *)realloc(string, strlen(string) + strlen(temp[i]) + 2); 631 | string = strcat(string, "\n"); 632 | string = strcat(string, temp[i]); 633 | } 634 | } 635 | } 636 | return string; 637 | } 638 | 639 | 640 | /* Separates the objects in the given char * arg using "\n\n" as 641 | separator. Returns a linked list whose data consist of separated 642 | objects as char * */ 643 | 644 | GList * take_objects(char * arg) 645 | { 646 | char ** objects=NULL; 647 | char ** temp = NULL; 648 | char * temp_object; 649 | GList * tobereturned = NULL; 650 | int i; 651 | 652 | arg = strip_lines(arg); 653 | 654 | objects = g_strsplit(arg, "\n\n", 1000); 655 | temp = objects; 656 | for (i=0; temp[i] != NULL; i++) 657 | { 658 | /* strip off the trailing and leading white spaces-eols*/ 659 | g_strstrip(temp[i]); 660 | if (strlen(temp[i]) > 0) 661 | { /* if not an empty string */ 662 | /* here we must add a "\n" at the end of the object, since RAToolSet parser can't 663 | find the last attrib otherwise */ 664 | temp_object = (char *)malloc(strlen(temp[i]) + 2); 665 | snprintf(temp_object, strlen(temp[i]) + 2, "%s\n", temp[i]); 666 | tobereturned = g_list_append(tobereturned, temp_object); 667 | } 668 | } 669 | return tobereturned; 670 | } 671 | 672 | 673 | 674 | /* takes the first object in the given char *, using empty lines as 675 | separator */ 676 | char * take_object(char * arg) 677 | { 678 | GList * objects; 679 | char * object; 680 | 681 | objects = take_objects(arg); 682 | if (g_list_length(objects) > 0) 683 | { 684 | object = strdup((char *)(g_list_nth_data(objects, 0))); 685 | } 686 | else 687 | { 688 | return NULL; 689 | } 690 | g_list_free(objects); 691 | 692 | return object; 693 | } 694 | 695 | 696 | 697 | /* Takes an autnum_object, and returns the as-block containing this aut-num */ 698 | char * get_as_block(rpsl_object_t *autnum_object) 699 | { 700 | char * search_key = NULL, * query_string = NULL; 701 | char * result = NULL; 702 | char *return_value = NULL; 703 | 704 | search_key = get_search_key(autnum_object,"aut-num"); 705 | 706 | query_string = (char *)malloc(strlen("-Tas-block -r ")+strlen(search_key)+1); 707 | sprintf(query_string, "-Tas-block -r %s",search_key); 708 | result = send_and_get(query_host, query_port, query_string); 709 | free(query_string); 710 | 711 | if (count_objects(result) == 0) 712 | { 713 | if (tracing) 714 | { 715 | printf("No such as-block\n"); 716 | } 717 | free(result); 718 | return NULL; 719 | } 720 | else if (count_objects(result) > 1) 721 | { 722 | if (tracing) 723 | { 724 | printf("More than one as-block returned\n"); 725 | } 726 | free(result); 727 | return NULL; 728 | } 729 | else 730 | { /* count_objects(result) == 1 */ 731 | return_value = take_object(result); 732 | free(result); 733 | return return_value; 734 | } 735 | } 736 | 737 | 738 | /* Takes a route_object, and returns the aut-num mentioned in origin 739 | attribute of this route */ 740 | char * get_aut_num_object(rpsl_object_t *route_object) 741 | { 742 | char * search_key = NULL, * query_string = NULL; 743 | char * result = NULL; 744 | char *return_value = NULL; 745 | 746 | search_key = get_search_key(route_object,"origin"); 747 | 748 | query_string = (char *)malloc(strlen("-Taut-num -r ")+strlen(search_key)+1); 749 | sprintf(query_string, "-Taut-num -r %s",search_key); 750 | result = send_and_get(query_host, query_port, query_string); 751 | free(query_string); 752 | 753 | if (count_objects(result) == 0) 754 | { 755 | if (tracing) 756 | { 757 | printf("No such aut-num\n"); 758 | } 759 | free(result); 760 | return NULL; 761 | } 762 | else if (count_objects(result) > 1) 763 | { 764 | if (tracing) 765 | { 766 | printf("More than one aut-num returned\n"); 767 | } 768 | free(result); 769 | return NULL; 770 | } 771 | else 772 | { /* count_objects(result) == 1 */ 773 | return_value = take_object(result); 774 | free(result); 775 | return return_value; 776 | } 777 | } 778 | 779 | 780 | 781 | /* Takes a parsed domain_object, and returns the less specific domain of it */ 782 | char * get_less_specific_domain(rpsl_object_t *domain_object) 783 | { 784 | char *query_string = NULL; 785 | char *result = NULL, *domain = NULL; 786 | char *return_value = NULL; 787 | int i,j, length; 788 | char *temp = NULL; 789 | char **splitted; 790 | 791 | domain = get_search_key(domain_object,"domain"); 792 | 793 | /* split the domain from its dots ('50' is the max # of pieces, this number is just arbitrary) */ 794 | splitted = g_strsplit((char *)strdup(domain), ".", 50); 795 | 796 | for (i=1; splitted[i] != NULL; i++) 797 | { 798 | /* in the following for loop, we will construct the 'less spec' domains 799 | to be looked up in the DB */ 800 | for (j=i; splitted[j] !=NULL; j++) 801 | { 802 | if (j==i) 803 | { 804 | temp = (char *)strdup(splitted[j]); 805 | } 806 | else 807 | { 808 | length = strlen(temp); 809 | temp = (char *)realloc(temp, length + strlen(splitted[j]) + 2); 810 | strcat(temp, "."); 811 | strcat(temp, splitted[j]); 812 | } 813 | } 814 | 815 | query_string = (char *)malloc( strlen("-Tdomain -r -R ")+strlen(temp)+1 ); 816 | sprintf(query_string, "-Tdomain -r -R %s", temp); 817 | result = send_and_get(query_host, query_port, query_string); 818 | free(query_string); 819 | free(temp); 820 | 821 | if (count_objects(result) == 0) 822 | { 823 | /* do nothing */ 824 | free(result); 825 | } 826 | else if (count_objects(result) > 1) 827 | { 828 | if (tracing) 829 | { 830 | printf("TRACING: get_less_specific_domain: More than one domains returned\n"); 831 | } 832 | free(result); 833 | return NULL; /* error condition */ 834 | } 835 | else 836 | { /* count_objects(result) == 1 */ 837 | return_value = take_object(result); 838 | free(result); 839 | return return_value; 840 | } 841 | } 842 | g_strfreev(splitted); 843 | 844 | /* so, we couldn't find any 'less specific' domain */ 845 | return NULL; 846 | } 847 | 848 | 849 | 850 | /* Takes a hierarchical set_object, and returns the less specific set or auth-num of it 851 | by striping down the object's name ( eg, for as35:rs-trial:rs-myset, 852 | as35:rs-trial is tried ) */ 853 | char * get_less_specific_set(rpsl_object_t *set_object, const char *type) 854 | { 855 | char *search_key = NULL, *query_string = NULL; 856 | char *result = NULL; 857 | char *return_value = NULL; 858 | int i; 859 | 860 | search_key = get_search_key(set_object, type); 861 | 862 | for (i = strlen(search_key) -1; i > -1; i--) 863 | { 864 | if (search_key[i] == ':') 865 | { 866 | search_key[i] = '\0'; /* truncate the string */ 867 | break; 868 | } 869 | if (i == 0) 870 | { /* if we've reached the beginning of the string 871 | (this means there wasn't any ';' in the string) */ 872 | free(search_key); 873 | search_key = NULL; 874 | } 875 | } 876 | if ( search_key == NULL || strlen(search_key) == 0) 877 | { /* this mustn't happen in fact, since 878 | we make sure that the name of the 879 | set_object contains a ':' in a proper place */ 880 | return NULL; 881 | } 882 | 883 | query_string = (char *)malloc(strlen("-Taut-num,as-set,rtr-set,peering-set,filter-set,route-set -r ") 884 | + strlen(search_key) + 1); 885 | sprintf(query_string, "-Taut-num,as-set,rtr-set,peering-set,filter-set,route-set -r %s", search_key); 886 | result = send_and_get(query_host, query_port, query_string); 887 | free(search_key); 888 | free(query_string); 889 | 890 | if (count_objects(result) == 0) 891 | { 892 | if (tracing) 893 | { 894 | printf("get_less_specific_set: No such object\n"); 895 | } 896 | free(result); 897 | return NULL; 898 | } 899 | else if (count_objects(result) > 1) 900 | { 901 | if (tracing) 902 | { 903 | printf("get_less_specific_set: More than one objects returned\n"); 904 | } 905 | free(result); 906 | return NULL; 907 | } 908 | else 909 | { /* count_objects(result) == 1 */ 910 | return_value = take_object(result); 911 | free(result); 912 | return return_value; 913 | } 914 | } 915 | 916 | 917 | 918 | /* Takes an inetnum or inet6num object and returns one less specific of it */ 919 | char * get_less_specific(rpsl_object_t *inetnum_object, const char *type) 920 | { 921 | char *search_key = NULL, *query_string = NULL; 922 | char *result = NULL; 923 | char *return_value = NULL; 924 | 925 | search_key = get_search_key(inetnum_object, type); 926 | 927 | query_string = (char *)malloc(strlen("-Tinet6num -r -l ") + strlen(search_key) + 1); 928 | sprintf(query_string, "-T%s -r -l %s",type, search_key); 929 | result = send_and_get(query_host, query_port, query_string); 930 | free(search_key); 931 | free(query_string); 932 | 933 | if (count_objects(result) == 0) 934 | { 935 | printf("No such type %s\n", type); 936 | free(result); 937 | return NULL; 938 | } 939 | else if (count_objects(result) > 1) 940 | { 941 | printf("More than one %s returned\n", type); 942 | free(result); 943 | return NULL; 944 | } 945 | else 946 | { /* count_objects(result) == 1 */ 947 | return_value = take_object(result); 948 | free(result); 949 | return return_value; 950 | } 951 | } 952 | 953 | 954 | 955 | /* Takes a parsed route object and returns one less specific inetnum */ 956 | char * get_less_spec_inetnum(rpsl_object_t *route_object) 957 | { 958 | char * search_key = NULL, * query_string = NULL; 959 | char * result = NULL; 960 | char * return_value = NULL; 961 | 962 | search_key = get_search_key(route_object, "route"); 963 | 964 | query_string = (char *)malloc(strlen("-Tinetnum -r -l ") + strlen(search_key) + 1); 965 | sprintf(query_string, "-Tinetnum -r -l %s", search_key); 966 | result = send_and_get(query_host, query_port, query_string); 967 | free(search_key); 968 | free(query_string); 969 | 970 | if (count_objects(result) == 0) 971 | { 972 | if (tracing) 973 | { 974 | printf("get_less_spec_inetnum: No such inetnum\n"); 975 | } 976 | free(result); 977 | return NULL; 978 | } 979 | else if (count_objects(result) > 1) 980 | { 981 | if (tracing) 982 | { 983 | printf("get_less_spec_inetnum: More than one inetnums returned\n"); 984 | } 985 | free(result); 986 | return NULL; 987 | } 988 | else 989 | { /* count_objects(result) == 1 */ 990 | return_value = take_object(result); 991 | free(result); 992 | return return_value; 993 | } 994 | } 995 | 996 | 997 | /* Takes a parsed route object and returns exact match inetnum */ 998 | char * get_exact_match_inetnum(rpsl_object_t *route_object) 999 | { 1000 | char * search_key = NULL, * query_string = NULL; 1001 | char * result = NULL; 1002 | char * return_value = NULL; 1003 | 1004 | search_key = get_search_key(route_object, "route"); 1005 | 1006 | query_string = (char *)malloc(strlen("-Tinetnum -r -x ") + strlen(search_key) + 1); 1007 | sprintf(query_string, "-Tinetnum -r -x %s", search_key); 1008 | result = send_and_get(query_host, query_port, query_string); 1009 | free(search_key); 1010 | free(query_string); 1011 | 1012 | if (count_objects(result) == 0) 1013 | { 1014 | if (tracing) 1015 | { 1016 | printf("get_exact_match_inetnum: No such inetnum\n"); 1017 | } 1018 | free(result); 1019 | return NULL; 1020 | } 1021 | else if (count_objects(result) > 1) 1022 | { 1023 | if (tracing) 1024 | { 1025 | printf("get_exact_match_inetnum: More than one inetnums returned\n"); 1026 | } 1027 | free(result); 1028 | return NULL; 1029 | } 1030 | else 1031 | { /* count_objects(result) == 1 */ 1032 | return_value = take_object(result); 1033 | free(result); 1034 | return return_value; 1035 | } 1036 | } 1037 | 1038 | 1039 | 1040 | /* Takes a route object and returns exact matches of this route */ 1041 | GList *get_exact_match_routes(rpsl_object_t *route_object) 1042 | { 1043 | char *search_key = NULL, *query_string = NULL; 1044 | char *result = NULL; 1045 | GList * return_value = NULL; 1046 | 1047 | search_key = get_search_key(route_object, "route"); 1048 | 1049 | query_string = (char *)malloc(strlen("-Troute -r -x ") + strlen(search_key) + 1); 1050 | sprintf(query_string, "-Troute -r -x %s", search_key); 1051 | result = send_and_get(query_host, query_port, query_string); 1052 | free(search_key); 1053 | free(query_string); 1054 | 1055 | if (count_objects(result) == 0) 1056 | { 1057 | if (tracing) 1058 | { 1059 | printf("get_exact_match_routes: No such route\n"); 1060 | } 1061 | free(result); 1062 | return NULL; 1063 | } 1064 | else 1065 | { /* count_objects(result) >= 1 */ 1066 | return_value = take_objects(result); 1067 | free(result); 1068 | return return_value; 1069 | } 1070 | } 1071 | 1072 | 1073 | 1074 | /* Takes a route object and returns (immediate) less specifics of this route */ 1075 | GList *get_less_spec_routes(rpsl_object_t *route_object) 1076 | { 1077 | char *search_key = NULL, *query_string = NULL; 1078 | char *result = NULL; 1079 | GList * return_value = NULL; 1080 | 1081 | search_key = get_search_key(route_object, "route"); 1082 | 1083 | query_string = (char *)malloc(strlen("-Troute -r -l ") + strlen(search_key) + 1); 1084 | sprintf(query_string, "-Troute -r -l %s", search_key); 1085 | result = send_and_get(query_host, query_port, query_string); 1086 | free(search_key); 1087 | free(query_string); 1088 | 1089 | if (count_objects(result) == 0) 1090 | { 1091 | if(tracing) 1092 | { 1093 | printf("get_less_spec_routes: No such route\n"); 1094 | } 1095 | free(result); 1096 | return NULL; 1097 | } 1098 | else 1099 | { /* count_objects(result) >= 1 */ 1100 | return_value = take_objects(result); 1101 | free(result); 1102 | return return_value; 1103 | } 1104 | } 1105 | 1106 | 1107 | 1108 | /* Gets an object as a parsed structure and returns its 'mnt-by' attributes as a 1109 | GList (linked list) */ 1110 | 1111 | GList *get_mntners(rpsl_object_t *object) 1112 | { 1113 | GList *list_of_mntners = NULL; 1114 | 1115 | if(tracing) 1116 | { 1117 | printf("TRACING: get_mntners is running\n"); 1118 | } 1119 | 1120 | list_of_mntners = rpsl_object_get_attr(object, "mnt-by"); 1121 | 1122 | return list_of_mntners; 1123 | } 1124 | 1125 | 1126 | 1127 | /* Gets an object as a parsed structure and returns its 'mnt-irt' attributes as a 1128 | GList (linked list) */ 1129 | 1130 | GList *get_irts(rpsl_object_t *object) 1131 | { 1132 | GList *list_of_irts = NULL; 1133 | 1134 | if(tracing) 1135 | { 1136 | printf("TRACING: get_irts is running\n"); 1137 | } 1138 | 1139 | list_of_irts = rpsl_object_get_attr(object, "mnt-irt"); 1140 | 1141 | return list_of_irts; 1142 | } 1143 | 1144 | 1145 | 1146 | /* Gets a GList of strings and returns 1 if one of them starts with substr, 0 otherwise */ 1147 | int strstr_in_list(GList *list, const char *substr) 1148 | { 1149 | GList * item = NULL; 1150 | char * word; 1151 | 1152 | if (tracing) 1153 | { 1154 | printf("TRACING: strstr_in_list is running\n"); 1155 | } 1156 | 1157 | for ( item = list; item != NULL ; item = g_list_next(item) ) 1158 | { 1159 | word = strdup((char *)(item->data)); 1160 | g_strup(word); 1161 | if (strstr(word, substr) == word) 1162 | { 1163 | free(word); 1164 | return 1; 1165 | } 1166 | free(word); 1167 | } 1168 | /* none of them matched, so return 0 */ 1169 | return 0; 1170 | } 1171 | 1172 | /* Gets a GList of attr structures and returns 1 if one of their (upper case)values starts with substr, 0 otherwise */ 1173 | int strstr_in_attr_list(GList * list, const char * substr) 1174 | { 1175 | GList * item = NULL; 1176 | char * word; 1177 | 1178 | if (tracing) 1179 | { 1180 | printf("TRACING: strstr_in_attr_list is running\n"); 1181 | } 1182 | 1183 | for( item = list; item != NULL ; item = g_list_next(item) ) 1184 | { 1185 | word = rpsl_attr_get_clean_value((rpsl_attr_t *)(item->data)); 1186 | g_strup(word); 1187 | if (strstr(word, substr) == word) 1188 | { 1189 | free(word); 1190 | return 1; 1191 | } 1192 | free(word); 1193 | } 1194 | /* none of them matched, so return 0 */ 1195 | return 0; 1196 | } 1197 | 1198 | 1199 | 1200 | /* Gets a (maintainer/irt) object as a string and returns its 'auth' attributes 1201 | as a GList (linked list) */ 1202 | 1203 | GList *get_auths(char * object_str) 1204 | { 1205 | const char *name = NULL; 1206 | char *value = NULL; 1207 | GList *attr; 1208 | rpsl_object_t *object; 1209 | GList *list_of_auths = NULL; 1210 | 1211 | if(tracing) 1212 | { 1213 | printf("TRACING: get_auths is running\n"); 1214 | } 1215 | object = rpsl_object_init(object_str); 1216 | 1217 | list_of_auths = rpsl_object_get_attr(object, "auth"); 1218 | 1219 | if(tracing) 1220 | { 1221 | if ( rpsl_object_has_error(object, RPSL_ERRLVL_ERROR) ) 1222 | { 1223 | /* thre was an error during the parsing */ 1224 | name = rpsl_object_get_class(object); 1225 | if ( name ) 1226 | { 1227 | attr = rpsl_object_get_attr(object, name); 1228 | if ( attr ) 1229 | { 1230 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(attr->data) ); 1231 | if ( value ) 1232 | { 1233 | printf("TRACING: get_auths: error parsing object %s\n", value ); 1234 | free(value); 1235 | } 1236 | else 1237 | printf("TRACING: get_auths: error parsing object\n"); 1238 | 1239 | rpsl_attr_delete_list(attr); 1240 | } 1241 | } 1242 | } 1243 | printf("TRACING: get_auths: returning (with %d nodes)\n", g_list_length(list_of_auths)); 1244 | } 1245 | 1246 | rpsl_object_delete(object); 1247 | return list_of_auths; 1248 | } 1249 | 1250 | 1251 | 1252 | /* Gets a parsed object and returns its 'attr_type' attributes as a 1253 | GList (linked list) */ 1254 | 1255 | GList *get_attr_list(rpsl_object_t *object, const char *attr_type) 1256 | { 1257 | GList *list_of_attrs = NULL; 1258 | char *object_str = NULL; 1259 | 1260 | if (tracing) 1261 | { 1262 | object_str = rpsl_object_get_text(object,0); 1263 | printf("TRACING: get_attr_list is running searching for %s, object is [\n%s]\n", attr_type ? attr_type : "NULL", object_str ? object_str : "NULL"); 1264 | free(object_str); 1265 | } 1266 | 1267 | list_of_attrs = rpsl_object_get_attr(object, attr_type); 1268 | 1269 | return list_of_attrs; 1270 | } 1271 | 1272 | 1273 | 1274 | /* Gets a parsed object and returns its mnt_lower attributes as a 1275 | GList (linked list) */ 1276 | 1277 | GList *get_mnt_lowers(rpsl_object_t *object) 1278 | { 1279 | GList *list_of_mnt_lowers = NULL; 1280 | 1281 | if (tracing) 1282 | { 1283 | printf("TRACING: get_mnt_lowers is running\n"); 1284 | } 1285 | 1286 | list_of_mnt_lowers = rpsl_object_get_attr(object, "mnt-lower"); 1287 | 1288 | return list_of_mnt_lowers; 1289 | } 1290 | 1291 | 1292 | /* Gets a parsed object and returns its mnt_routes attributes as a 1293 | GList (linked list) */ 1294 | 1295 | GList *get_mnt_routes(rpsl_object_t *object) 1296 | { 1297 | GList *list_of_mnt_routes = NULL; 1298 | 1299 | if (tracing) 1300 | { 1301 | printf("TRACING: get_mnt_routes is running\n"); 1302 | } 1303 | 1304 | list_of_mnt_routes = rpsl_object_get_attr(object, "mnt-routes"); 1305 | 1306 | return list_of_mnt_routes; 1307 | } 1308 | 1309 | 1310 | /* Gets a linked list of object strings and returns the mnt_routes attribs of 1311 | them in a linked list */ 1312 | GList *get_mnt_routes_from_list(GList *objects_str) 1313 | { 1314 | GList *objects_str_item = NULL; 1315 | GList *list_of_mnt_routes = NULL; 1316 | const char *name = NULL; 1317 | char *value = NULL; 1318 | GList *attr; 1319 | rpsl_object_t *object; 1320 | 1321 | for ( objects_str_item = objects_str; objects_str_item != NULL ; objects_str_item = g_list_next(objects_str_item) ) 1322 | { 1323 | object = rpsl_object_init((char *)(objects_str_item->data)); 1324 | 1325 | if (tracing) 1326 | { 1327 | if ( rpsl_object_has_error(object, RPSL_ERRLVL_ERROR) ) 1328 | { 1329 | /* thre was an error during the parsing */ 1330 | name = rpsl_object_get_class(object); 1331 | if ( name ) 1332 | { 1333 | attr = rpsl_object_get_attr(object, name); 1334 | if ( attr ) 1335 | { 1336 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(attr->data) ); 1337 | if ( value ) 1338 | { 1339 | printf("TRACING: get_mnt_routes_from_list: error parsing object %s\n", value ); 1340 | free(value); 1341 | } 1342 | else 1343 | printf("TRACING: get_mnt_routes_from_list: error parsing object\n"); 1344 | 1345 | rpsl_attr_delete_list(attr); 1346 | } 1347 | } 1348 | } 1349 | } 1350 | 1351 | list_of_mnt_routes = g_list_concat(list_of_mnt_routes, get_mnt_routes(object)); 1352 | rpsl_object_delete(object); 1353 | } 1354 | 1355 | return list_of_mnt_routes; 1356 | } 1357 | 1358 | 1359 | 1360 | /* Gets a linked list of object strings and returns the mnt_lowers attribs of 1361 | them in a linked list */ 1362 | GList *get_mnt_lowers_from_list(GList * objects_str) 1363 | { 1364 | GList *objects_str_item = NULL; 1365 | GList *list_of_mnt_lowers = NULL; 1366 | const char *name = NULL; 1367 | char *value = NULL; 1368 | GList *attr; 1369 | rpsl_object_t *object; 1370 | 1371 | for( objects_str_item = objects_str; objects_str_item != NULL ; objects_str_item = g_list_next(objects_str_item) ) 1372 | { 1373 | object = rpsl_object_init((char *)(objects_str_item->data)); 1374 | 1375 | if (tracing) 1376 | { 1377 | if ( rpsl_object_has_error(object, RPSL_ERRLVL_ERROR) ) 1378 | { 1379 | /* thre was an error during the parsing */ 1380 | name = rpsl_object_get_class(object); 1381 | if ( name ) 1382 | { 1383 | attr = rpsl_object_get_attr(object, name); 1384 | if ( attr ) 1385 | { 1386 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(attr->data) ); 1387 | if ( value ) 1388 | { 1389 | printf("TRACING: get_mnt_routes_from_list: error parsing object %s\n", value ); 1390 | free(value); 1391 | } 1392 | else 1393 | printf("TRACING: get_mnt_routes_from_list: error parsing object\n"); 1394 | 1395 | rpsl_attr_delete_list(attr); 1396 | } 1397 | } 1398 | } 1399 | } 1400 | 1401 | list_of_mnt_lowers = g_list_concat(list_of_mnt_lowers, get_mnt_lowers(object)); 1402 | rpsl_object_delete(object); 1403 | } 1404 | 1405 | return list_of_mnt_lowers; 1406 | } 1407 | 1408 | 1409 | /* Gets a linked list of object strings and returns the mnt-by attribs of 1410 | them in a linked list */ 1411 | GList *get_mntners_from_list(GList *objects_str) 1412 | { 1413 | GList *objects_str_item = NULL; 1414 | GList *list_of_mntners = NULL; 1415 | const char *name = NULL; 1416 | char *value = NULL; 1417 | GList *attr; 1418 | rpsl_object_t *object; 1419 | 1420 | for ( objects_str_item = objects_str; objects_str_item != NULL ; objects_str_item = g_list_next(objects_str_item) ) 1421 | { 1422 | object = rpsl_object_init((char *)(objects_str_item->data)); 1423 | 1424 | if (tracing) 1425 | { 1426 | if ( rpsl_object_has_error(object, RPSL_ERRLVL_ERROR) ) 1427 | { 1428 | /* thre was an error during the parsing */ 1429 | name = rpsl_object_get_class(object); 1430 | if ( name ) 1431 | { 1432 | attr = rpsl_object_get_attr(object, name); 1433 | if ( attr ) 1434 | { 1435 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(attr->data) ); 1436 | if ( value ) 1437 | { 1438 | printf("TRACING: get_mnt_routes_from_list: error parsing object %s\n", value ); 1439 | free(value); 1440 | } 1441 | else 1442 | printf("TRACING: get_mnt_routes_from_list: error parsing object\n"); 1443 | 1444 | rpsl_attr_delete_list(attr); 1445 | } 1446 | } 1447 | } 1448 | } 1449 | 1450 | list_of_mntners = g_list_concat(list_of_mntners, get_mntners(object)); 1451 | rpsl_object_delete(object); 1452 | } 1453 | 1454 | return list_of_mntners; 1455 | } 1456 | 1457 | 1458 | 1459 | /* retrieves the override password from the 'override' attribute 1460 | of the object. If none, it returns NULL */ 1461 | char *get_override(rpsl_object_t * object) 1462 | { 1463 | 1464 | GList *attr_list; 1465 | 1466 | if(tracing) 1467 | { 1468 | printf("TRACING: get_override is running\n"); 1469 | } 1470 | 1471 | attr_list = rpsl_object_get_attr(object, "override"); 1472 | if ( ! attr_list ) 1473 | { 1474 | /* there was no 'override' attrib, so return NULL */ 1475 | return NULL; 1476 | } 1477 | 1478 | /* there should only be one item in this list, 1479 | return the clean value of that attribute */ 1480 | return strdup(rpsl_attr_get_value((rpsl_attr_t *)(attr_list->data))); 1481 | } 1482 | 1483 | 1484 | 1485 | /* checks override string (password) 1486 | returns OVR_OK if it is correct password */ 1487 | int check_override(char * string) 1488 | { 1489 | char ** temp; 1490 | int i; 1491 | char * crypted_password = strdup(overridecryptedpw); 1492 | 1493 | if(string == NULL) 1494 | { 1495 | if(tracing) 1496 | { 1497 | printf("TRACING: check_override is returning FAILED\n"); 1498 | } 1499 | free (crypted_password); 1500 | return UP_OVF; /* override attempt failed */ 1501 | } 1502 | else 1503 | { 1504 | /* split the string */ 1505 | temp = g_strsplit (string, " ", 0); 1506 | 1507 | for(i=0; temp[i] != NULL; i++) 1508 | { 1509 | if(strlen(temp[i]) != 0) 1510 | { 1511 | if(strcmp(AU_crypt(temp[i], crypted_password), crypted_password) == 0) 1512 | { 1513 | if(tracing) 1514 | { 1515 | printf("TRACING: check_override is returning %s OK\n", string); 1516 | } 1517 | g_strfreev(temp); 1518 | free (crypted_password); 1519 | return OVR_OK; 1520 | } 1521 | } 1522 | } 1523 | 1524 | /* we couldn't find a word matching the override password */ 1525 | g_strfreev(temp); 1526 | free (crypted_password); 1527 | return UP_OVF; /* override attempt failed */ 1528 | } 1529 | } 1530 | 1531 | 1532 | 1533 | 1534 | /* takes a GSList of struct auth_struct and a GList of auths, and a mntner/irt name, 1535 | add new elements to GSList of struct auth_struct and returns the new 1536 | GSList of struct auth_struct */ 1537 | 1538 | GSList * add_to_auth_vector(GSList * list_of_auth_struct, GList * auths, char * mntner_name) 1539 | { 1540 | GList * auth_item; 1541 | char * auth_attrib = NULL; 1542 | char * auth_attrib_uppercase = NULL, * argument = NULL; 1543 | auth_struct * temp = NULL; 1544 | int index = 1; 1545 | 1546 | for (auth_item = auths; auth_item != NULL; auth_item = g_list_next(auth_item)) 1547 | { 1548 | auth_attrib = rpsl_attr_get_clean_value((rpsl_attr_t *)(auth_item->data)); 1549 | if(tracing) 1550 | { 1551 | printf("TRACING: add_to_auth_vector: %s\n", auth_attrib); 1552 | } 1553 | /* Take the auth attribute and convert it into uppercase for comparisons */ 1554 | auth_attrib_uppercase = strdup(auth_attrib); 1555 | g_strup(auth_attrib_uppercase); 1556 | 1557 | if ( strstr(auth_attrib_uppercase,"CRYPT-PW") == auth_attrib_uppercase ) 1558 | { 1559 | /* take the argument of the auth attribute */ 1560 | argument = strdup(auth_attrib + strlen("CRYPT-PW")); 1561 | g_strstrip(argument); 1562 | if(tracing) 1563 | { 1564 | printf("TRACING: add_to_auth_vector: adding new argument: %s\n", argument); 1565 | } 1566 | temp = (auth_struct *)malloc(sizeof(auth_struct)); 1567 | temp->type = AU_CRYPT_PW; 1568 | temp->auth = argument; 1569 | temp->mntner_name = mntner_name; 1570 | temp->index = index++; 1571 | list_of_auth_struct = g_slist_append(list_of_auth_struct, temp); 1572 | } 1573 | else if (strstr(auth_attrib_uppercase,"MAIL-FROM") == auth_attrib_uppercase) 1574 | { 1575 | /* take the argument of the auth attribute */ 1576 | argument = strdup(auth_attrib + strlen("MAIL-FROM")); 1577 | g_strstrip(argument); 1578 | if(tracing) 1579 | { 1580 | printf("TRACING: add_to_auth_vector: adding new argument: %s\n", argument); 1581 | } 1582 | temp = (auth_struct *)malloc(sizeof(auth_struct)); 1583 | temp->type = AU_MAIL_FROM; 1584 | temp->auth = argument; 1585 | temp->mntner_name = mntner_name; 1586 | temp->index = index++; 1587 | list_of_auth_struct = g_slist_append(list_of_auth_struct, temp); 1588 | } 1589 | else if (strstr(auth_attrib_uppercase,"NONE") == auth_attrib_uppercase) 1590 | { 1591 | /* take the argument of the auth attribute */ 1592 | temp = (auth_struct *)malloc(sizeof(auth_struct)); 1593 | temp->type = AU_NONE; 1594 | temp->auth = NULL; 1595 | temp->mntner_name = mntner_name; 1596 | temp->index = index++; 1597 | list_of_auth_struct = g_slist_append(list_of_auth_struct, temp); 1598 | } 1599 | else if (strstr(auth_attrib_uppercase,"PGPKEY-") == auth_attrib_uppercase) 1600 | { 1601 | argument = strdup(auth_attrib + strlen("PGPKEY-")); 1602 | g_strstrip(argument); 1603 | if(tracing) 1604 | { 1605 | printf("TRACING: add_to_auth_vector: adding new argument: %s\n", argument); 1606 | } 1607 | temp = (auth_struct *)malloc(sizeof(auth_struct)); 1608 | temp->type = AU_PGP; 1609 | temp->mntner_name = mntner_name; 1610 | temp->index = index++; 1611 | temp->auth = argument; 1612 | list_of_auth_struct = g_slist_append(list_of_auth_struct, temp); 1613 | } 1614 | else 1615 | { 1616 | if (tracing) 1617 | { 1618 | printf("TRACING: Error: invalid auth attrib: %s\n", auth_attrib); 1619 | } 1620 | return NULL; 1621 | } 1622 | 1623 | free(auth_attrib_uppercase); 1624 | free(auth_attrib); 1625 | } 1626 | 1627 | return list_of_auth_struct; 1628 | } 1629 | 1630 | 1631 | 1632 | 1633 | /* Gets a list of mntner names, retrieves those mntners from 1634 | the database and extracts the 'auth' attributes, and 1635 | constructs the authorisation vector, which is a GSList of 1636 | struct auth_struct */ 1637 | 1638 | GSList * get_auth_vector(GList * mntners) 1639 | { 1640 | GList * list_of_auths = NULL; 1641 | GList * mntner_item = NULL; 1642 | GSList * to_be_returned = NULL; 1643 | char * query_string = NULL, * result = NULL, * object_str = NULL; 1644 | char *value; 1645 | 1646 | for( mntner_item = mntners; mntner_item != NULL ; mntner_item = g_list_next(mntner_item) ) 1647 | { 1648 | value = rpsl_attr_get_clean_value((rpsl_attr_t *)(mntner_item->data)); 1649 | if(tracing) 1650 | { 1651 | printf("=====\nget_auth_vector: Got a mntner\n%s\n", value ); 1652 | } 1653 | query_string = (char *)malloc(strlen("-Tmntner -r ")+strlen(value)+1); 1654 | sprintf(query_string, "-Tmntner -r %s",value); 1655 | result = send_and_get(query_host, query_port, query_string); 1656 | free(query_string); 1657 | if (count_objects(result) == 0) 1658 | { 1659 | /* no such maintainer */ 1660 | if(tracing) 1661 | { 1662 | printf("get_auth_vector: No such maintainer %s\n", value); 1663 | } 1664 | free(result); 1665 | free(value); 1666 | return NULL; 1667 | } 1668 | else if (count_objects(result) > 1) 1669 | { 1670 | if(tracing) 1671 | { 1672 | printf("get_auth_vector: More than one objects returned for %s\n", value); 1673 | } 1674 | } 1675 | else 1676 | { /* count_objects(result) == 1 */ 1677 | object_str = take_object(result); 1678 | if(tracing) 1679 | { 1680 | printf("TRACING: get_auth_vector: Calling get_auths with object [\n%s]\n", object_str); 1681 | } 1682 | 1683 | list_of_auths = get_auths(object_str); 1684 | if(tracing) 1685 | { 1686 | printf("TRACING: get_auth_vector: get_auths returned (with %d nodes)\n", g_list_length(list_of_auths)) ; 1687 | } 1688 | 1689 | /* add this to the auth_vector. ( mntner_item->data->value is the name of the maintainer ) */ 1690 | to_be_returned = add_to_auth_vector(to_be_returned, list_of_auths, (char *)value); 1691 | if(tracing) 1692 | { 1693 | printf("TRACING: get_auth_vector: to_be_returned has now %d nodes\n", g_slist_length(to_be_returned)); 1694 | } 1695 | 1696 | rpsl_attr_delete_list(list_of_auths); 1697 | } 1698 | free(value); 1699 | free(result); 1700 | } 1701 | 1702 | if(tracing) 1703 | { 1704 | printf("TRACING: get_auth_vector: to_be_returned has %i nodes\n", g_slist_length(to_be_returned)); 1705 | } 1706 | return to_be_returned; 1707 | } 1708 | 1709 | 1710 | 1711 | /* Gets a list of irt names, retrieves those irts from 1712 | the database and extracts the 'auth' attributes, and 1713 | constructs the authorisation vector, which is a GSList of 1714 | struct auth_struct */ 1715 | 1716 | GSList * get_irt_auth_vector(GList * irts) 1717 | { 1718 | GList * list_of_auths = NULL; 1719 | GList * irt_item = NULL; 1720 | GSList * to_be_returned = NULL; 1721 | char * query_string = NULL, * result = NULL, * object_str = NULL; 1722 | char *value; 1723 | 1724 | for( irt_item = irts; irt_item != NULL ; irt_item = g_list_next(irt_item) ) 1725 | { 1726 | value = rpsl_attr_get_clean_value((rpsl_attr_t *)(irt_item->data)); 1727 | if(tracing) 1728 | { 1729 | printf("=====\nget_irt_auth_vector: Got an irt\n%s\n", value ); 1730 | } 1731 | query_string = (char *)malloc(strlen("-Tirt -r ")+strlen(value)+1); 1732 | sprintf(query_string, "-Tirt -r %s",value); 1733 | result = send_and_get(query_host, query_port, query_string); 1734 | free(query_string); 1735 | if (count_objects(result) == 0) 1736 | { 1737 | /* no such irt */ 1738 | if(tracing) 1739 | { 1740 | printf("get_irt_auth_vector: No such irt %s\n", value); 1741 | } 1742 | free(result); 1743 | free(value); 1744 | return NULL; 1745 | } 1746 | else if (count_objects(result) > 1) 1747 | { 1748 | if(tracing) 1749 | { 1750 | printf("get_irt_auth_vector: More than one objects returned for %s\n", value); 1751 | } 1752 | } 1753 | else 1754 | { /* count_objects(result) == 1 */ 1755 | object_str = take_object(result); 1756 | if(tracing) 1757 | { 1758 | printf("TRACING: get_irt_auth_vector: Calling get_auths with object [\n%s]\n", object_str); 1759 | } 1760 | 1761 | list_of_auths = get_auths(object_str); 1762 | if(tracing) 1763 | { 1764 | printf("TRACING: get_irt_auth_vector: get_auths returned (with %d nodes)\n", g_list_length(list_of_auths)) ; 1765 | } 1766 | 1767 | /* add this to the auth_vector. ( irt_item->data->value is the name of the irt ) */ 1768 | to_be_returned = add_to_auth_vector(to_be_returned, list_of_auths, (char *)value); 1769 | if(tracing) 1770 | { 1771 | printf("TRACING: get_irt_auth_vector: to_be_returned has now %d nodes\n", g_slist_length(to_be_returned)); 1772 | } 1773 | 1774 | rpsl_attr_delete_list(list_of_auths); 1775 | } 1776 | free(value); 1777 | free(result); 1778 | } 1779 | 1780 | if(tracing) 1781 | { 1782 | printf("TRACING: get_irt_auth_vector: to_be_returned has %i nodes\n", g_slist_length(to_be_returned)); 1783 | } 1784 | return to_be_returned; 1785 | } 1786 | 1787 | 1788 | 1789 | 1790 | /* Gets a list of mntner attributes, retrieves those mntners from 1791 | the database and extracts the 'mnt-nfy' attributes, and 1792 | returns them as a GList */ 1793 | 1794 | GList * get_mntnfy_vector(GList *mntners) 1795 | { 1796 | GList * list_of_mntnfy = NULL; 1797 | GList * mntner_item = NULL; 1798 | GList * temp; 1799 | const GList * error_list = NULL; 1800 | char * query_string = NULL, * result = NULL, * object_str = NULL; 1801 | char *value; 1802 | rpsl_object_t *object; 1803 | 1804 | for ( mntner_item = mntners; mntner_item != NULL ; mntner_item = g_list_next(mntner_item) ) 1805 | { 1806 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(mntner_item->data) ); 1807 | if (tracing) 1808 | { 1809 | printf( "=====\nGot a mntner\n%s\n", value ); 1810 | } 1811 | query_string = (char *)malloc(strlen("-Tmntner -r ")+strlen(value)+1); 1812 | sprintf(query_string, "-Tmntner -r %s", value); 1813 | result = send_and_get(query_host, query_port, query_string); 1814 | free(query_string); 1815 | if (count_objects(result) == 0) 1816 | { 1817 | /* no such maintainer */ 1818 | if(tracing) 1819 | { 1820 | printf("get_mntnfy_vector: No such maintainer %s\n", value); 1821 | } 1822 | } 1823 | else if (count_objects(result) > 1) 1824 | { 1825 | if (tracing) 1826 | { 1827 | printf("get_mntnfy_vector: More than one objects returned for maintainer %s\n", value); 1828 | } 1829 | } 1830 | else 1831 | { /* count_objects(result) == 1 */ 1832 | object_str = take_object(result); 1833 | object = rpsl_object_init(object_str); 1834 | error_list = rpsl_object_errors(object); 1835 | 1836 | if (tracing) 1837 | { 1838 | printf("TRACING: get_mntnfy_vector: Calling get_attr_list\n"); 1839 | } 1840 | 1841 | temp = get_attr_list(object, "mnt-nfy"); 1842 | 1843 | if (tracing) 1844 | { 1845 | printf("TRACING: get_mntnfy_vector: get_attr_list returned (with %i nodes)\n", g_list_length(temp)); 1846 | } 1847 | 1848 | list_of_mntnfy = g_list_concat(list_of_mntnfy, temp); 1849 | 1850 | if (tracing) 1851 | { 1852 | printf("TRACING: get_mntnfy_vector: list_of_mntnfy has now %i nodes\n", g_list_length(list_of_mntnfy)); 1853 | } 1854 | rpsl_object_delete(object); 1855 | } 1856 | free(value); 1857 | free(result); 1858 | } 1859 | 1860 | if (tracing) 1861 | { 1862 | printf("TRACING: get_mntnfy_vector: list_of_mntnfy has %i nodes\n", g_list_length(list_of_mntnfy)); 1863 | } 1864 | return list_of_mntnfy; 1865 | } 1866 | 1867 | 1868 | 1869 | 1870 | /* Gets a list of irt attributes, retrieves those irts from 1871 | the database and extracts the 'irt-nfy' attributes, and 1872 | returns them as a GList */ 1873 | 1874 | GList * get_irtnfy_vector(GList *irts) 1875 | { 1876 | GList * list_of_irtnfy = NULL; 1877 | GList * irt_item = NULL; 1878 | GList * temp; 1879 | const GList * error_list = NULL; 1880 | char * query_string = NULL, * result = NULL, * object_str = NULL; 1881 | char *value; 1882 | rpsl_object_t *object; 1883 | 1884 | for ( irt_item = irts; irt_item != NULL ; irt_item = g_list_next(irt_item) ) 1885 | { 1886 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(irt_item->data) ); 1887 | if (tracing) 1888 | { 1889 | printf( "=====\nGot a irt\n%s\n", value ); 1890 | } 1891 | query_string = (char *)malloc(strlen("-Tirt -r ")+strlen(value)+1); 1892 | sprintf(query_string, "-Tirt -r %s", value); 1893 | result = send_and_get(query_host, query_port, query_string); 1894 | free(query_string); 1895 | if (count_objects(result) == 0) 1896 | { 1897 | /* no such irt */ 1898 | if(tracing) 1899 | { 1900 | printf("get_irtnfy_vector: No such irt %s\n", value); 1901 | } 1902 | } 1903 | else if (count_objects(result) > 1) 1904 | { 1905 | if (tracing) 1906 | { 1907 | printf("get_irtnfy_vector: More than one objects returned for irt %s\n", value); 1908 | } 1909 | } 1910 | else 1911 | { /* count_objects(result) == 1 */ 1912 | object_str = take_object(result); 1913 | object = rpsl_object_init(object_str); 1914 | error_list = rpsl_object_errors(object); 1915 | 1916 | if (tracing) 1917 | { 1918 | printf("TRACING: get_irtnfy_vector: Calling get_attr_list\n"); 1919 | } 1920 | 1921 | temp = get_attr_list(object, "irt-nfy"); 1922 | 1923 | if (tracing) 1924 | { 1925 | printf("TRACING: get_irtnfy_vector: get_attr_list returned (with %i nodes)\n", g_list_length(temp)); 1926 | } 1927 | 1928 | list_of_irtnfy = g_list_concat(list_of_irtnfy, temp); 1929 | 1930 | if (tracing) 1931 | { 1932 | printf("TRACING: get_irtnfy_vector: list_of_irtnfy has now %i nodes\n", g_list_length(list_of_irtnfy)); 1933 | } 1934 | rpsl_object_delete(object); 1935 | } 1936 | free(value); 1937 | free(result); 1938 | } 1939 | 1940 | if (tracing) 1941 | { 1942 | printf("TRACING: get_irtnfy_vector: list_of_irtnfy has %i nodes\n", g_list_length(list_of_irtnfy)); 1943 | } 1944 | return list_of_irtnfy; 1945 | } 1946 | 1947 | 1948 | 1949 | /* Gets a list of mntner names, retrieves those mntners from 1950 | the database and extracts the 'upd-to' attributes, and 1951 | returns them as a GList */ 1952 | 1953 | GList * get_updto_vector(GList * mntners) 1954 | { 1955 | GList * list_of_updto = NULL; 1956 | GList * mntner_item = NULL; 1957 | char * query_string = NULL, * result = NULL, * object_str = NULL; 1958 | GList * temp; 1959 | const GList * error_list = NULL; 1960 | char *value; 1961 | rpsl_object_t *object; 1962 | 1963 | for ( mntner_item = mntners; mntner_item != NULL ; mntner_item = g_list_next(mntner_item) ) 1964 | { 1965 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(mntner_item->data) ); 1966 | if (tracing) 1967 | { 1968 | printf( "=====\nGot a mntner\n%s\n", value ); 1969 | } 1970 | query_string = (char *)malloc(strlen("-Tmntner -r ")+strlen(value)+1); 1971 | sprintf(query_string, "-Tmntner -r %s", value); 1972 | result = send_and_get(query_host, query_port, query_string); 1973 | if (count_objects(result) == 0) 1974 | { 1975 | /* no such maintainer */ 1976 | if(tracing) 1977 | { 1978 | printf("get_updto_vector: No such maintainer %s\n", value); 1979 | } 1980 | } 1981 | else if(count_objects(result) > 1) 1982 | { 1983 | if (tracing) 1984 | { 1985 | printf("get_updto_vector: More than one objects returned for maintainer %s\n", value); 1986 | } 1987 | } 1988 | else 1989 | { /* count_objects(result) == 1 */ 1990 | object_str = take_object(result); 1991 | object = rpsl_object_init(object_str); 1992 | error_list = rpsl_object_errors(object); 1993 | 1994 | if (tracing) 1995 | { 1996 | printf("TRACING: get_updto_vector: Calling get_attr_list\n"); 1997 | } 1998 | 1999 | temp = get_attr_list(object, "upd-to"); 2000 | 2001 | if (tracing) 2002 | { 2003 | printf("TRACING: get_updto_vector: get_attr_list returned (with %i nodes)\n", g_list_length(temp)); 2004 | } 2005 | 2006 | list_of_updto = g_list_concat(list_of_updto, temp); 2007 | 2008 | if (tracing) 2009 | { 2010 | printf("TRACING: get_updto_vector: list_of_mntnfy has now %i nodes\n", g_list_length(list_of_updto)); 2011 | } 2012 | rpsl_object_delete(object); 2013 | } 2014 | free(value); 2015 | free(result); 2016 | } 2017 | 2018 | if (tracing) 2019 | { 2020 | printf("TRACING: get_updto_vector: list_of_updto has %i nodes\n", g_list_length(list_of_updto)); 2021 | } 2022 | return list_of_updto; 2023 | } 2024 | 2025 | 2026 | 2027 | 2028 | /* gets one or more route objects filters out the ones which don't have the same 2029 | origin as 'char * origin' argument */ 2030 | char * up_filter_out_diff_origins(char * objects_str, char * origin) 2031 | { 2032 | GList * object_str_list = NULL, * object_str_item =NULL; 2033 | const GList *error_list = NULL; 2034 | char * objects_to_be_returned = NULL; 2035 | char * key = NULL; 2036 | rpsl_object_t *object; 2037 | 2038 | if (tracing) 2039 | { 2040 | printf("TRACING: up_filter_out_diff_origins\n"); 2041 | } 2042 | 2043 | /* strip the lines beginning with '%' off */ 2044 | objects_str = strip_lines(objects_str); 2045 | 2046 | /* separate the objects, store them in a linked list */ 2047 | object_str_list = take_objects(objects_str); 2048 | 2049 | for (object_str_item = object_str_list; object_str_item != NULL; object_str_item = g_list_next(object_str_item)) 2050 | { 2051 | object = rpsl_object_init((char *)(object_str_item->data)); 2052 | error_list = rpsl_object_errors(object); 2053 | key = get_search_key(object, "origin"); 2054 | if (key != NULL && strcasecmp(g_strstrip(origin), key) == 0) 2055 | { 2056 | if (objects_to_be_returned == NULL) 2057 | { 2058 | objects_to_be_returned = strdup((char *)(object_str_item->data)); 2059 | } 2060 | else 2061 | { 2062 | objects_to_be_returned = (char *)realloc(objects_to_be_returned, 2063 | strlen(objects_to_be_returned) + strlen((char *)(object_str_item->data)) + 2); 2064 | objects_to_be_returned = strcat(objects_to_be_returned, "\n"); 2065 | objects_to_be_returned = strcat(objects_to_be_returned, (char *)(object_str_item->data)); 2066 | } 2067 | } 2068 | rpsl_object_delete(object); 2069 | free(key); 2070 | } 2071 | 2072 | if(tracing) 2073 | { 2074 | printf("TRACING: up_filter_out_diff_origins: returning:\n%s\n", objects_to_be_returned ? objects_to_be_returned : "(NULL)"); 2075 | } 2076 | 2077 | return objects_to_be_returned; 2078 | } 2079 | 2080 | 2081 | 2082 | /* gets one or more person/role objects filters out the ones which don't have the same 2083 | nic_hdl as 'char * nic_hdl' argument */ 2084 | char * up_filter_out_diff_nichdls(char * objects_str, char * nic_hdl) 2085 | { 2086 | GList * object_str_list = NULL, * object_str_item =NULL; 2087 | char * objects_to_be_returned = NULL; 2088 | char * key = NULL; 2089 | rpsl_object_t *object; 2090 | 2091 | if (tracing) 2092 | { 2093 | printf("TRACING: up_filter_out_diff_nichdls\n"); 2094 | } 2095 | 2096 | /* strip the lines beginning with '%' off */ 2097 | objects_str = strip_lines(objects_str); 2098 | 2099 | /* separate the objects strings, store them in a linked list */ 2100 | object_str_list = take_objects(objects_str); 2101 | 2102 | for (object_str_item = object_str_list; object_str_item != NULL; object_str_item = g_list_next(object_str_item)) 2103 | { 2104 | object = rpsl_object_init((char *)(object_str_item->data)); 2105 | key = get_search_key(object, "nic-hdl"); 2106 | if (key != NULL && strcasecmp(g_strstrip(nic_hdl), key) == 0) 2107 | { 2108 | if (objects_to_be_returned == NULL) 2109 | { 2110 | objects_to_be_returned = strdup((char *)(object_str_item->data)); 2111 | } 2112 | else 2113 | { 2114 | objects_to_be_returned = (char *)realloc(objects_to_be_returned, 2115 | strlen(objects_to_be_returned) + strlen((char *)(object_str_item->data)) + 2); 2116 | objects_to_be_returned = strcat(objects_to_be_returned, "\n"); 2117 | objects_to_be_returned = strcat(objects_to_be_returned, (char *)(object_str_item->data)); 2118 | } 2119 | } 2120 | rpsl_object_delete(object); 2121 | } 2122 | 2123 | if(tracing) 2124 | { 2125 | printf("TRACING: up_filter_out_diff_nichdls: returning:\n%s\n", objects_to_be_returned ? objects_to_be_returned :"(NULL)"); 2126 | } 2127 | 2128 | return objects_to_be_returned; 2129 | } 2130 | 2131 | 2132 | 2133 | /* gets one or more route objects, filters out the ones which have the same 2134 | origin as 'char * origin' argument */ 2135 | char * UP_filter_out_same_origins(char * objects_str, rpsl_object_t * object) 2136 | { 2137 | GList * object_list = NULL, * object_item =NULL; 2138 | const GList *error_list = NULL; 2139 | char * objects_to_be_returned = NULL; 2140 | char * key = NULL; 2141 | rpsl_object_t *obj; 2142 | char * origin; 2143 | 2144 | if (tracing) 2145 | { 2146 | printf("TRACING: UP_filter_out_same_origins\n"); 2147 | } 2148 | 2149 | origin = get_search_key(object, "origin"); 2150 | 2151 | /* strip the lines beginning with '%' off */ 2152 | objects_str = strip_lines(objects_str); 2153 | 2154 | /* separate the objects, store them in a linked list */ 2155 | object_list = take_objects(objects_str); 2156 | 2157 | for (object_item = object_list; object_item != NULL; object_item = g_list_next(object_item)) 2158 | { 2159 | obj = rpsl_object_init((char *)(object_item->data)); 2160 | error_list = rpsl_object_errors(obj); 2161 | 2162 | key = get_search_key(obj, "origin"); 2163 | if (key != NULL && strcasecmp(g_strstrip(origin), key) != 0) 2164 | { 2165 | if (objects_to_be_returned == NULL) 2166 | { 2167 | objects_to_be_returned = strdup((char *)(object_item->data)); 2168 | } 2169 | else 2170 | { 2171 | objects_to_be_returned = (char *)realloc(objects_to_be_returned, 2172 | strlen(objects_to_be_returned) + strlen((char *)(object_item->data)) + 2); 2173 | objects_to_be_returned = strcat(objects_to_be_returned, "\n"); 2174 | objects_to_be_returned = strcat(objects_to_be_returned, (char *)(object_item->data)); 2175 | } 2176 | } 2177 | rpsl_object_delete(obj); 2178 | } 2179 | 2180 | if (tracing) 2181 | { 2182 | printf("TRACING: up_filter_out_same_origins: returning:\n%s\n", objects_to_be_returned ? objects_to_be_returned : "(NULL)"); 2183 | } 2184 | 2185 | return objects_to_be_returned; 2186 | } 2187 | 2188 | 2189 | 2190 | 2191 | /* Check authorisation 2192 | Applies authorisation rules according to the object type 2193 | 2194 | Arguments: 2195 | char *new_object: the new object, 2196 | char *old_object: the old object, as found in the database, 2197 | char *type: type of the object 2198 | credentials_struct credentials: a struct which 2199 | contains credentials of the update, such as 'From:' field of 2200 | the e-mail header and passwords in the update */ 2201 | 2202 | int check_auth(rpsl_object_t *new_object, rpsl_object_t *old_object, const char *type, credentials_struct credentials) 2203 | { 2204 | GList *old_mntners = NULL, *new_mntners = NULL; 2205 | GList *old_irts = NULL, *new_irts = NULL; 2206 | GList *changed_irts = NULL; 2207 | GList *as_block_mnt_lowers = NULL; 2208 | GSList *old_auth_vector = NULL, *new_auth_vector = NULL; 2209 | GSList *changed_auth_vector = NULL; 2210 | GSList *as_block_auth_vector = NULL; 2211 | GSList *less_specific_auth_vector = NULL; 2212 | GList *less_specific_mnt_lowers = NULL; 2213 | GList *less_specific_mntners = NULL; 2214 | GList *aut_num_maintainers = NULL; 2215 | GSList *aut_num_auth_vector = NULL; 2216 | GList *exact_match_routes_str = NULL; 2217 | GList *exact_match_routes_maintainers = NULL; 2218 | GSList *exact_match_routes_auth_vector = NULL; 2219 | GList *less_spec_routes_str = NULL; 2220 | GList *less_spec_routes_mntners = NULL; 2221 | GSList *less_spec_routes_auth_vector = NULL; 2222 | GList *exact_match_inetnum_mnt_routes = NULL; 2223 | GSList *exact_match_inetnum_auth_vector = NULL; 2224 | GList *less_spec_inetnum_mntners = NULL; 2225 | GSList *less_spec_inetnum_auth_vector = NULL; 2226 | GList *less_spec_inetnum_mnt_bys = NULL; 2227 | GList *exact_match_inetnum_mnt_bys; 2228 | 2229 | GList *old_name = NULL; 2230 | GList *new_name = NULL; 2231 | GList *attr; 2232 | const GList *error_list = NULL; 2233 | GList *status_attrs; 2234 | 2235 | char *less_specific_status; 2236 | char *old_status; 2237 | char *new_status; 2238 | char *as_block_object_str = NULL; 2239 | char *less_specific_object_str = NULL; 2240 | char *less_specific_domain_str = NULL; 2241 | char *less_spec_inetnum_str = NULL; 2242 | char *exact_match_inetnum_str = NULL; 2243 | const char *less_specific_object_type = NULL; 2244 | char *override_string = NULL; 2245 | char *set_name = NULL; 2246 | char * aut_num_object_str = NULL; 2247 | char * name_old = NULL; 2248 | char * name_new = NULL; 2249 | const char *name; 2250 | int aut_num_auth_OK = FALSE; 2251 | 2252 | int auth_return; 2253 | char *value; 2254 | 2255 | rpsl_object_t *as_block_obj = NULL; 2256 | rpsl_object_t *less_specific_obj = NULL; 2257 | rpsl_object_t *less_specific_domain_obj = NULL; 2258 | rpsl_object_t *aut_num_obj = NULL; 2259 | rpsl_object_t *exact_match_inetnum_obj = NULL; 2260 | rpsl_object_t *less_spec_inetnum_obj = NULL; 2261 | 2262 | int overriden = 0; 2263 | 2264 | if (tracing) 2265 | { 2266 | printf("TRACING: check_auth is running with object type [%s]\n", type); 2267 | } 2268 | 2269 | /* first check if it is overriden or not. if overriden, check the override 2270 | password. If it is correct, continue, setting "overriden" to 1. If not, 2271 | immediately exit returning ERR_UP_OVF */ 2272 | override_string = get_override((new_object == NULL) ? old_object : new_object ); 2273 | if(override_string == NULL) 2274 | { 2275 | if (tracing) 2276 | { 2277 | printf("TRACING: overriden not set\n"); 2278 | } 2279 | overriden = 0; 2280 | } 2281 | else if ( check_override(override_string) == OVR_OK ) 2282 | { 2283 | if (tracing) 2284 | { 2285 | printf("TRACING: overriden set\n"); 2286 | } 2287 | overriden = 1; /* authorisation is overriden */ 2288 | free(override_string); 2289 | override_string = NULL; 2290 | } 2291 | else 2292 | { 2293 | if (tracing) 2294 | { 2295 | printf("TRACING: override failed\n"); 2296 | } 2297 | free(override_string); 2298 | override_string = NULL; 2299 | return UP_OVF; /* override failed! */ 2300 | } 2301 | 2302 | 2303 | /* 2304 | * Handle the "person", "role", "limerick", "inet-rtr", "key-cert" types 2305 | */ 2306 | if(strcmp(type,"person") == 0 || strcmp(type,"role") == 0 || 2307 | strcmp(type,"limerick") == 0 || strcmp(type,"inet-rtr") == 0 || 2308 | strcmp(type,"key-cert") == 0 ) 2309 | { 2310 | if( new_object == NULL && old_object != NULL ) 2311 | { /* the object is to be deleted */ 2312 | old_mntners = get_mntners(old_object); 2313 | old_auth_vector = get_auth_vector(old_mntners); 2314 | if (old_mntners != NULL && old_auth_vector == NULL) 2315 | { 2316 | /* then, the mntners in 'old_mntners' do not exist. Problem. */ 2317 | rpsl_attr_delete_list(old_mntners); 2318 | return UP_AUF; /* auth failed */ 2319 | } 2320 | auth_return = authorise(old_auth_vector, credentials, overriden); 2321 | if (old_auth_vector) 2322 | g_slist_free(old_auth_vector); 2323 | return auth_return; 2324 | } 2325 | else if ( new_object != NULL && old_object == NULL ) 2326 | { /* the object is to be created */ 2327 | new_mntners = get_mntners(new_object); 2328 | new_auth_vector = get_auth_vector(new_mntners); 2329 | if(new_mntners != NULL && new_auth_vector == NULL) 2330 | { 2331 | /* then, the mntners in 'new_mntners' do not exist. Problem. */ 2332 | rpsl_attr_delete_list(new_mntners); 2333 | return UP_AUF; /* auth failed */ 2334 | } 2335 | auth_return = authorise(new_auth_vector, credentials, overriden); 2336 | if (new_auth_vector) 2337 | g_slist_free(new_auth_vector); 2338 | return auth_return; 2339 | } 2340 | else if ( new_object != NULL && old_object != NULL ) 2341 | { /* this is an update */ 2342 | /* check name change of person/role */ 2343 | if ( strcmp(type,"person") == 0 || strcmp(type,"role") == 0 ) 2344 | { 2345 | old_name = get_attr_list(old_object, type); 2346 | new_name = get_attr_list(new_object, type); 2347 | 2348 | if(old_name != NULL && new_name != NULL 2349 | && g_list_nth(old_name, 0) != NULL && g_list_nth(new_name, 0) != NULL 2350 | && (g_list_nth(old_name, 0)->data) != NULL 2351 | && (g_list_nth(new_name, 0)->data) != NULL) 2352 | { 2353 | 2354 | name_old = rpsl_attr_get_clean_value((rpsl_attr_t *)(g_list_nth(old_name, 0)->data)); 2355 | name_new = rpsl_attr_get_clean_value((rpsl_attr_t *)(g_list_nth(new_name, 0)->data)); 2356 | rpsl_attr_delete_list(old_name); 2357 | rpsl_attr_delete_list(new_name); 2358 | 2359 | if ( strcmp(name_old, name_new) ) 2360 | { 2361 | free(name_old); free(name_new); 2362 | return UP_NAM; /* name of a person/role object can't be changed */ 2363 | } 2364 | free(name_old);free(name_new); 2365 | } 2366 | else 2367 | { 2368 | rpsl_attr_delete_list(old_name); 2369 | rpsl_attr_delete_list(new_name); 2370 | return UP_INT; /* there was a problem with obtaining the name of person obj */ 2371 | } 2372 | } 2373 | 2374 | old_mntners = get_mntners(old_object); 2375 | old_auth_vector = get_auth_vector(old_mntners); 2376 | if (old_mntners != NULL && old_auth_vector == NULL) 2377 | { 2378 | /* then, the mntners in 'old_mntners' do not exist. Problem. */ 2379 | rpsl_attr_delete_list(old_mntners); 2380 | return UP_AUF; /* auth failed */ 2381 | } 2382 | if (old_auth_vector) 2383 | { /* if we have mntners in the old object, use them */ 2384 | auth_return = authorise(old_auth_vector, credentials, overriden); 2385 | g_slist_free(old_auth_vector); 2386 | return auth_return; 2387 | } 2388 | else 2389 | { 2390 | new_mntners = get_mntners(new_object); 2391 | new_auth_vector = get_auth_vector(new_mntners); 2392 | if (new_mntners != NULL && new_auth_vector == NULL) 2393 | { 2394 | /* then, the mntners in 'new_mntners' do not exist. Problem. */ 2395 | rpsl_attr_delete_list(new_mntners); 2396 | return UP_AUF; /* auth failed */ 2397 | } 2398 | auth_return = authorise(new_auth_vector, credentials, overriden); 2399 | if (new_auth_vector) 2400 | g_slist_free(new_auth_vector); 2401 | return auth_return; 2402 | } 2403 | } 2404 | else 2405 | { /* both are NULL, mustn't happen */ 2406 | if (tracing) 2407 | { 2408 | printf("TRACING: check_auth: internal error: Both pointers are NULL\n"); 2409 | } 2410 | return UP_INT; /* internal error */ 2411 | } 2412 | } 2413 | 2414 | /* 2415 | * Handle the "aut-num" type 2416 | */ 2417 | else if (strcmp(type,"aut-num") == 0 ) 2418 | { 2419 | if ( new_object == NULL && old_object != NULL ) 2420 | { /* the object is to be deleted */ 2421 | old_mntners = get_mntners(old_object); 2422 | old_auth_vector = get_auth_vector(old_mntners); 2423 | if (old_mntners != NULL && old_auth_vector == NULL) 2424 | { 2425 | /* then, the mntners in 'old_mntners' do not exist. Problem. */ 2426 | rpsl_attr_delete_list(old_mntners); 2427 | return UP_AUF; /* auth failed */ 2428 | } 2429 | auth_return = authorise(old_auth_vector, credentials, overriden); 2430 | g_slist_free(old_auth_vector); 2431 | return auth_return; 2432 | } 2433 | else if ( new_object != NULL && old_object == NULL ) 2434 | { /* the object is to be created */ 2435 | as_block_object_str = get_as_block(new_object); 2436 | if (as_block_object_str == NULL ) 2437 | { 2438 | return UP_ABN; /* As-block does not exist */ 2439 | } 2440 | else 2441 | { 2442 | as_block_obj = rpsl_object_init(as_block_object_str); 2443 | if (tracing) 2444 | { 2445 | if ( rpsl_object_has_error(as_block_obj, RPSL_ERRLVL_ERROR) ) 2446 | { 2447 | /* thre was an error during the parsing */ 2448 | name = rpsl_object_get_class(as_block_obj); 2449 | if ( name ) 2450 | { 2451 | attr = rpsl_object_get_attr(as_block_obj, name); 2452 | if ( attr ) 2453 | { 2454 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(attr->data) ); 2455 | if ( value ) 2456 | { 2457 | printf("TRACING: get_mnt_routes_from_list: error parsing as_block object %s\n", value ); 2458 | free(value); 2459 | } 2460 | else 2461 | printf("TRACING: get_mnt_routes_from_list: error parsing as_block object\n"); 2462 | 2463 | rpsl_attr_delete_list(attr); 2464 | } 2465 | } 2466 | } 2467 | } 2468 | 2469 | as_block_mnt_lowers = get_mnt_lowers(as_block_obj); 2470 | as_block_auth_vector = get_auth_vector(as_block_mnt_lowers); 2471 | rpsl_object_delete(as_block_obj); 2472 | if (as_block_mnt_lowers != NULL && as_block_auth_vector == NULL) 2473 | { 2474 | /* then, the mntners in 'as_block_mnt_lowers' do not exist. Problem. */ 2475 | rpsl_attr_delete_list(as_block_mnt_lowers); 2476 | return UP_AUF; /* auth failed */ 2477 | } 2478 | if (authorise(as_block_auth_vector, credentials, overriden) == UP_AUTH_OK ) 2479 | { 2480 | new_mntners = get_mntners(new_object); 2481 | new_auth_vector = get_auth_vector(new_mntners); 2482 | if(new_mntners != NULL && new_auth_vector == NULL) 2483 | { 2484 | /* then, the mntners in 'new_auth_vector' do not exist. Problem. */ 2485 | rpsl_attr_delete_list(new_mntners); 2486 | return UP_AUF; /* auth failed */ 2487 | } 2488 | auth_return = authorise(new_auth_vector, credentials, overriden); 2489 | if (new_auth_vector) 2490 | g_slist_free(new_auth_vector); 2491 | return auth_return; 2492 | } 2493 | else 2494 | { 2495 | return UP_HOF; /* hierarchical auth failed */ 2496 | } 2497 | } 2498 | } 2499 | else if( new_object != NULL && old_object != NULL ) 2500 | { /* this is an update */ 2501 | old_mntners = get_mntners(old_object); 2502 | old_auth_vector = get_auth_vector(old_mntners); 2503 | if (old_mntners != NULL && old_auth_vector == NULL) 2504 | { 2505 | /* then, the mntners in 'old_mntners' do not exist. Problem. */ 2506 | rpsl_attr_delete_list(old_mntners); 2507 | return UP_AUF; /* auth failed */ 2508 | } 2509 | if (old_auth_vector) 2510 | { /* if we have mntners in the old object, use them */ 2511 | auth_return = authorise(old_auth_vector, credentials, overriden); 2512 | g_slist_free(old_auth_vector); 2513 | return auth_return; 2514 | } 2515 | else 2516 | { 2517 | new_mntners = get_mntners(new_object); 2518 | new_auth_vector = get_auth_vector(new_mntners); 2519 | if (new_mntners != NULL && new_auth_vector == NULL) 2520 | { 2521 | /* then, the mntners in 'new_mntners' do not exist. Problem. */ 2522 | rpsl_attr_delete_list(new_mntners); 2523 | return UP_AUF; /* auth failed */ 2524 | } 2525 | auth_return = authorise(new_auth_vector, credentials, overriden); 2526 | if (new_auth_vector) 2527 | g_slist_free(new_auth_vector); 2528 | return auth_return; 2529 | } 2530 | } 2531 | else 2532 | { /* both are NULL, mustn't happen */ 2533 | if(tracing) 2534 | { 2535 | printf("TRACING: check_auth: internal error: Both pointers are NULL\n"); 2536 | } 2537 | return UP_INT; /* internal error */ 2538 | } 2539 | } 2540 | 2541 | /* 2542 | * Handle the "mntner/as-block/irt" types 2543 | */ 2544 | else if (strcmp(type,"mntner") == 0 || strcmp(type,"as-block") == 0 || strcmp(type,"irt") == 0 ) 2545 | { 2546 | if ( new_object == NULL && old_object != NULL ) 2547 | { /* the object is to be deleted */ 2548 | old_mntners = get_mntners(old_object); 2549 | old_auth_vector = get_auth_vector(old_mntners); 2550 | if (old_mntners != NULL && old_auth_vector == NULL) 2551 | { 2552 | /* then, the mntners in 'old_mntners' do not exist. Problem. */ 2553 | rpsl_attr_delete_list(old_mntners); 2554 | return UP_AUF; /* auth failed */ 2555 | } 2556 | auth_return = authorise(old_auth_vector, credentials, overriden); 2557 | g_slist_free(old_auth_vector); 2558 | return auth_return; 2559 | } 2560 | else if ( new_object != NULL && old_object == NULL ) 2561 | { /* the object is to be created */ 2562 | if (overriden || test_mode) 2563 | { 2564 | return UP_AUTH_OK; 2565 | } 2566 | else 2567 | { /* If not overriden, must be forwarded to <HUMAILBOX> */ 2568 | if (tracing) 2569 | { 2570 | printf("TRACING: check_auth: '%s' creation requested\n", type); 2571 | } 2572 | return UP_FWD; /* must be forwarded to <HUMAILBOX> */ 2573 | } 2574 | } 2575 | else if ( new_object != NULL && old_object != NULL ) 2576 | { /* this is an update */ 2577 | old_mntners = get_mntners(old_object); 2578 | old_auth_vector = get_auth_vector(old_mntners); 2579 | if (old_mntners != NULL && old_auth_vector == NULL) 2580 | { 2581 | /* then, the mntners in 'old_mntners' do not exist. Problem. */ 2582 | rpsl_attr_delete_list(old_mntners); 2583 | return UP_AUF; /* auth failed */ 2584 | } 2585 | if (old_auth_vector) 2586 | { /* if we have mntners in the old object, use them */ 2587 | auth_return = authorise(old_auth_vector, credentials, overriden); 2588 | g_slist_free(old_auth_vector); 2589 | return auth_return; 2590 | } 2591 | else 2592 | { 2593 | new_mntners = get_mntners(new_object); 2594 | new_auth_vector = get_auth_vector(new_mntners); 2595 | if (new_mntners != NULL && new_auth_vector == NULL) 2596 | { 2597 | /* then, the mntners in 'new_mntners' do not exist. Problem. */ 2598 | rpsl_attr_delete_list(new_mntners); 2599 | return UP_AUF; /* auth failed */ 2600 | } 2601 | auth_return = authorise(new_auth_vector, credentials, overriden); 2602 | if (new_auth_vector) 2603 | g_slist_free(new_auth_vector); 2604 | return auth_return; 2605 | } 2606 | } 2607 | else 2608 | { /* both are NULL, mustn't happen */ 2609 | if (tracing) 2610 | { 2611 | printf("TRACING: check_auth: internal error: Both pointers are NULL\n"); 2612 | } 2613 | return UP_INT; /* internal error */ 2614 | } 2615 | } 2616 | 2617 | /* 2618 | * Handle the "inetnum/inet6num" types 2619 | */ 2620 | else if (strcmp(type,"inetnum") == 0 || strcmp(type,"inet6num") == 0 ) 2621 | { 2622 | if ( new_object == NULL && old_object != NULL ) 2623 | { 2624 | /* the object is to be deleted */ 2625 | /* dont check for mnt-irt on deletion */ 2626 | 2627 | /* check for mnt-irt */ 2628 | /* old_irts = get_irts(old_object); 2629 | old_auth_vector = get_irt_auth_vector(old_irts); 2630 | if (old_irts != NULL && old_auth_vector == NULL) 2631 | { 2632 | /* then, the irts in 'old_irts' do not exist. Problem. */ 2633 | /* rpsl_attr_delete_list(old_irts); 2634 | return UP_AUF; /* auth failed */ 2635 | /*} 2636 | auth_return = authorise(old_auth_vector, credentials, overriden); 2637 | g_slist_free(old_auth_vector); 2638 | if ( auth_return == UP_AUF ) 2639 | { 2640 | return UP_HOF; /* hierarchical authorisation failed */ 2641 | /*} */ 2642 | 2643 | /******* mntner check **********/ 2644 | old_mntners = get_mntners(old_object); 2645 | old_auth_vector = get_auth_vector(old_mntners); 2646 | if (old_mntners != NULL && old_auth_vector == NULL) 2647 | { 2648 | /* then, the mntners in 'old_mntners' do not exist. Problem. */ 2649 | rpsl_attr_delete_list(old_mntners); 2650 | return UP_AUF; /* auth failed */ 2651 | } 2652 | auth_return = authorise(old_auth_vector, credentials, overriden); 2653 | g_slist_free(old_auth_vector); 2654 | return auth_return; 2655 | } 2656 | else if ( new_object != NULL && old_object == NULL ) 2657 | { 2658 | /* the object is to be created */ 2659 | /******* irt check **********/ 2660 | /* if an object is created with an mnt-irt attribute, then it must 2661 | pass the authorisation for the mnt-irt */ 2662 | new_irts = get_irts(new_object); 2663 | new_auth_vector = get_irt_auth_vector(new_irts); 2664 | if (new_irts != NULL && new_auth_vector == NULL) 2665 | { 2666 | /* then, the irts in 'new_irts' do not exist. Problem. */ 2667 | rpsl_attr_delete_list(new_irts); 2668 | return UP_AUF; /* auth failed */ 2669 | } 2670 | auth_return = authorise(new_auth_vector, credentials, overriden); 2671 | if (new_auth_vector) 2672 | g_slist_free(new_auth_vector); 2673 | rpsl_attr_delete_list(new_irts); 2674 | if ( auth_return == UP_AUF ) 2675 | { 2676 | return UP_HOF; /* hierarchical authorisation failed */ 2677 | } 2678 | 2679 | /* get the one less specific inet(6)num object */ 2680 | less_specific_object_str = get_less_specific(new_object, type); 2681 | if (less_specific_object_str == NULL) 2682 | { 2683 | if (overriden) 2684 | { 2685 | return UP_AUTH_OK; 2686 | } 2687 | else 2688 | { 2689 | return UP_HOF; /* hierarchical authorisation failed */ 2690 | } 2691 | } 2692 | else 2693 | { /* if we got an inet(6)num object */ 2694 | less_specific_obj = rpsl_object_init(less_specific_object_str); 2695 | error_list = rpsl_object_errors(less_specific_obj); 2696 | if (tracing) 2697 | { 2698 | if ( rpsl_object_has_error(less_specific_obj, RPSL_ERRLVL_ERROR) ) 2699 | { 2700 | /* thre was an error during the parsing */ 2701 | name = rpsl_object_get_class(less_specific_obj); 2702 | if ( name ) 2703 | { 2704 | attr = rpsl_object_get_attr(less_specific_obj, name); 2705 | if ( attr ) 2706 | { 2707 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(attr->data) ); 2708 | if ( value ) 2709 | { 2710 | printf("TRACING: get_mnt_routes_from_list: error parsing object %s\n", value ); 2711 | free(value); 2712 | } 2713 | else 2714 | printf("TRACING: get_mnt_routes_from_list: error parsing object\n"); 2715 | 2716 | rpsl_attr_delete_list(attr); 2717 | } 2718 | } 2719 | } 2720 | } 2721 | 2722 | /******* status check **********/ 2723 | /* get the status of the inetnum object */ 2724 | status_attrs = rpsl_object_get_attr(new_object, "status"); 2725 | if ( status_attrs != NULL ) 2726 | { 2727 | new_status = rpsl_attr_get_clean_value((rpsl_attr_t *)(status_attrs->data)); 2728 | rpsl_attr_delete_list(status_attrs); 2729 | if ( ! strcmp(new_status, "LIR-PARTITIONED PA") || ! strcmp(new_status, "LIR-PARTITIONED PI") ) 2730 | { 2731 | /* get the status of the less specific object */ 2732 | status_attrs = rpsl_object_get_attr(less_specific_obj, "status"); 2733 | less_specific_status = rpsl_attr_get_clean_value((rpsl_attr_t *)(status_attrs->data)); 2734 | rpsl_attr_delete_list(status_attrs); 2735 | 2736 | if ( 2737 | ( (! strcmp(new_status, "LIR-PARTITIONED PA")) && strcmp(less_specific_status, "ALLOCATED PA") && strcmp(less_specific_status, "LIR-PARTITIONED PA") ) 2738 | || 2739 | ( (! strcmp(new_status, "LIR-PARTITIONED PI")) && strcmp(less_specific_status, "ALLOCATED PI") && strcmp(less_specific_status, "LIR-PARTITIONED PI") ) 2740 | ) 2741 | { 2742 | rpsl_object_delete(less_specific_obj); 2743 | return UP_HOF; /* hierarchical authorisation failed */ 2744 | } 2745 | } 2746 | free (new_status); 2747 | } 2748 | 2749 | /******* less_specific check **********/ 2750 | less_specific_mnt_lowers = get_mnt_lowers(less_specific_obj); 2751 | less_specific_auth_vector = get_auth_vector(less_specific_mnt_lowers); 2752 | rpsl_object_delete(less_specific_obj); 2753 | 2754 | if (less_specific_mnt_lowers != NULL && less_specific_auth_vector == NULL) 2755 | { 2756 | /* then, the mntners in 'less_specific_mnt_lowers' do not exist. Problem. */ 2757 | rpsl_attr_delete_list(less_specific_mnt_lowers); 2758 | return UP_AUF; /* auth failed */ 2759 | } 2760 | if (authorise(less_specific_auth_vector, credentials, overriden) == UP_AUTH_OK) 2761 | { 2762 | free(less_specific_auth_vector); 2763 | /******* mntner check **********/ 2764 | new_mntners = get_mntners(new_object); 2765 | new_auth_vector = get_auth_vector(new_mntners); 2766 | if (new_mntners != NULL && new_auth_vector == NULL) 2767 | { 2768 | /* then, the mntners in 'new_mntners' do not exist. Problem. */ 2769 | rpsl_attr_delete_list(new_mntners); 2770 | return UP_AUF; /* auth failed */ 2771 | } 2772 | auth_return = authorise(new_auth_vector, credentials, overriden); 2773 | if (new_auth_vector) 2774 | g_slist_free(new_auth_vector); 2775 | return auth_return; 2776 | } 2777 | else 2778 | { 2779 | return UP_HOF; /* hierarchical authorisation failed */ 2780 | } 2781 | } 2782 | } 2783 | else if ( new_object != NULL && old_object != NULL ) 2784 | { 2785 | /* this is an update */ 2786 | /******* status check **********/ 2787 | /* get the status of the old inetnum object */ 2788 | status_attrs = rpsl_object_get_attr(old_object, "status"); 2789 | if ( status_attrs != NULL ) 2790 | { 2791 | old_status = rpsl_attr_get_clean_value((rpsl_attr_t *)(status_attrs->data)); 2792 | rpsl_attr_delete_list(status_attrs); 2793 | } 2794 | else 2795 | old_status = strdup(""); /* to allow for legacy objects with no status */ 2796 | /* get the status of the new inetnum object */ 2797 | status_attrs = rpsl_object_get_attr(new_object, "status"); 2798 | if ( status_attrs != NULL ) 2799 | { 2800 | new_status = rpsl_attr_get_clean_value((rpsl_attr_t *)(status_attrs->data)); 2801 | rpsl_attr_delete_list(status_attrs); 2802 | } 2803 | else 2804 | new_status = NULL; 2805 | if (tracing) 2806 | { 2807 | printf("old_status [%s] new status [%s]\n", old_status ? old_status : "", 2808 | new_status ? new_status : "" ); 2809 | } 2810 | if ( strcmp(type,"inet6num") && strcmp(new_status, old_status) ) 2811 | { 2812 | /* if it is not an inet6num abject */ 2813 | /* (status is generated in inet6nums, so there will not be a new_status) */ 2814 | /* the status has changed, make sure the new value is allowed */ 2815 | if ( ! strcmp(new_status, "LIR-PARTITIONED PA") || ! strcmp(new_status, "LIR-PARTITIONED PI") ) 2816 | { 2817 | /* get the status of the less specific object */ 2818 | less_specific_object_str = get_less_specific(old_object, type); 2819 | less_specific_obj = rpsl_object_init(less_specific_object_str); 2820 | error_list = rpsl_object_errors(less_specific_obj); 2821 | 2822 | status_attrs = rpsl_object_get_attr(less_specific_obj, "status"); 2823 | less_specific_status = rpsl_attr_get_clean_value((rpsl_attr_t *)(status_attrs->data)); 2824 | rpsl_attr_delete_list(status_attrs); 2825 | rpsl_object_delete(less_specific_obj); 2826 | if (tracing) 2827 | { 2828 | printf("less_specific_status [%s] \n", less_specific_status); 2829 | } 2830 | 2831 | if ( 2832 | ( (! strcmp(new_status, "LIR-PARTITIONED PA")) && strcmp(less_specific_status, "ALLOCATED PA") && strcmp(less_specific_status, "LIR-PARTITIONED PA") ) 2833 | || 2834 | ( (! strcmp(new_status, "LIR-PARTITIONED PI")) && strcmp(less_specific_status, "ALLOCATED PI") && strcmp(less_specific_status, "LIR-PARTITIONED PI") ) 2835 | ) 2836 | { 2837 | free (old_status); 2838 | free (new_status); 2839 | return UP_HOF; /* hierarchical authorisation failed */ 2840 | } 2841 | } 2842 | free (old_status); 2843 | free (new_status); 2844 | } 2845 | 2846 | /******* irt check **********/ 2847 | /* check for mnt-irt in both old and new object */ 2848 | /* it only needs to pass the authorisation of an mnt-irt when the 2849 | mnt-irt is first added to the object */ 2850 | old_irts = get_irts(old_object); 2851 | new_irts = get_irts(new_object); 2852 | /* find irts that have just been added to this object */ 2853 | changed_irts = NT_compare_lists(old_irts, new_irts, 2); /* 2 means 'just added' */ 2854 | 2855 | changed_auth_vector = get_irt_auth_vector(changed_irts); 2856 | if (changed_irts != NULL && changed_auth_vector == NULL) 2857 | { 2858 | /* then, the irts in 'changed_irts' do not exist. Problem. */ 2859 | rpsl_attr_delete_list(old_irts); 2860 | rpsl_attr_delete_list(new_irts); 2861 | return UP_AUF; /* auth failed */ 2862 | } 2863 | auth_return = authorise(changed_auth_vector, credentials, overriden); 2864 | g_slist_free(changed_auth_vector); 2865 | rpsl_attr_delete_list(old_irts); 2866 | rpsl_attr_delete_list(new_irts); 2867 | if ( auth_return == UP_AUF ) 2868 | { 2869 | return UP_HOF; /* hierarchical authorisation failed */ 2870 | } 2871 | 2872 | /******* mntner check **********/ 2873 | old_mntners = get_mntners(old_object); 2874 | old_auth_vector = get_auth_vector(old_mntners); 2875 | if (old_mntners != NULL && old_auth_vector == NULL) 2876 | { 2877 | /* then, the mntners in 'old_mntners' do not exist. Problem. */ 2878 | rpsl_attr_delete_list(old_mntners); 2879 | return UP_AUF; /* auth failed */ 2880 | } 2881 | if (old_auth_vector) 2882 | { /* if we have mntners in the old object, use them */ 2883 | auth_return = authorise(old_auth_vector, credentials, overriden); 2884 | g_slist_free(old_auth_vector); 2885 | return auth_return; 2886 | } 2887 | else 2888 | { 2889 | new_mntners = get_mntners(new_object); 2890 | new_auth_vector = get_auth_vector(new_mntners); 2891 | if (new_mntners != NULL && new_auth_vector == NULL) 2892 | { 2893 | /* then, the mntners in 'new_mntners' do not exist. Problem. */ 2894 | rpsl_attr_delete_list(new_mntners); 2895 | return UP_AUF; /* auth failed */ 2896 | } 2897 | auth_return = authorise(new_auth_vector, credentials, overriden); 2898 | if (new_auth_vector) 2899 | g_slist_free(new_auth_vector); 2900 | return auth_return; 2901 | } 2902 | } 2903 | else 2904 | { /* both are NULL, mustn't happen */ 2905 | if (tracing) 2906 | { 2907 | printf("TRACING: check_auth: internal error: Both pointers are NULL\n"); 2908 | } 2909 | return UP_INT; /* internal error */ 2910 | } 2911 | } 2912 | 2913 | /* 2914 | * Handle the "domain" type 2915 | */ 2916 | else if (strcmp(type,"domain") == 0) 2917 | { 2918 | if ( new_object == NULL && old_object != NULL ) 2919 | { /* the object is to be deleted */ 2920 | old_mntners = get_mntners(old_object); 2921 | old_auth_vector = get_auth_vector(old_mntners); 2922 | if (old_mntners != NULL && old_auth_vector == NULL) 2923 | { 2924 | /* then, the mntners in 'old_mntners' do not exist. Problem. */ 2925 | rpsl_attr_delete_list(old_mntners); 2926 | return UP_AUF; /* auth failed */ 2927 | } 2928 | auth_return = authorise(old_auth_vector, credentials, overriden); 2929 | g_slist_free(old_auth_vector); 2930 | return auth_return; 2931 | } 2932 | else if ( new_object != NULL && old_object == NULL ) 2933 | { /* the object is to be created */ 2934 | /* now, we have to find a 'less specific domain object' for this. 2935 | If there is no less specific object, then creation is possible 2936 | only with overriding. */ 2937 | less_specific_domain_str = get_less_specific_domain(new_object); 2938 | if (less_specific_domain_str == NULL) 2939 | { 2940 | if (overriden) 2941 | {/* we didn't get a 'less specific' domain object */ 2942 | return UP_AUTH_OK; 2943 | } 2944 | else 2945 | { 2946 | return UP_HOF; /* hierarchical authorisation failed */ 2947 | } 2948 | } 2949 | else 2950 | { /* we get a 'less specific' domain object */ 2951 | less_specific_domain_obj = rpsl_object_init(less_specific_domain_str); 2952 | if (tracing) 2953 | { 2954 | if ( rpsl_object_has_error(less_specific_domain_obj, RPSL_ERRLVL_ERROR) ) 2955 | { 2956 | /* thre was an error during the parsing */ 2957 | name = rpsl_object_get_class(less_specific_domain_obj); 2958 | if ( name ) 2959 | { 2960 | attr = rpsl_object_get_attr(less_specific_domain_obj, name); 2961 | if ( attr ) 2962 | { 2963 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(attr->data) ); 2964 | if ( value ) 2965 | { 2966 | printf("TRACING: get_mnt_routes_from_list: error parsing object %s\n", value ); 2967 | free(value); 2968 | } 2969 | else 2970 | printf("TRACING: get_mnt_routes_from_list: error parsing object\n"); 2971 | 2972 | rpsl_attr_delete_list(attr); 2973 | } 2974 | } 2975 | } 2976 | } 2977 | 2978 | less_specific_mnt_lowers = get_mnt_lowers(less_specific_domain_obj); 2979 | less_specific_auth_vector = get_auth_vector(less_specific_mnt_lowers); 2980 | rpsl_object_delete(less_specific_domain_obj); 2981 | 2982 | if (less_specific_mnt_lowers != NULL && less_specific_auth_vector == NULL) 2983 | { 2984 | /* then, the mntners in 'less_specific_mnt_lowers' do not exist. Problem. */ 2985 | rpsl_attr_delete_list(less_specific_mnt_lowers); 2986 | return UP_AUF; /* auth failed */ 2987 | } 2988 | if (authorise(less_specific_auth_vector, credentials, overriden) == UP_AUTH_OK) 2989 | { 2990 | new_mntners = get_mntners(new_object); 2991 | new_auth_vector = get_auth_vector(new_mntners); 2992 | if (new_mntners != NULL && new_auth_vector == NULL) 2993 | { 2994 | /* then, the mntners in 'new_mntners' do not exist. Problem. */ 2995 | rpsl_attr_delete_list(new_mntners); 2996 | return UP_AUF; /* auth failed */ 2997 | } 2998 | auth_return = authorise(new_auth_vector, credentials, overriden); 2999 | if (new_auth_vector) 3000 | g_slist_free(new_auth_vector); 3001 | return auth_return; 3002 | } 3003 | else 3004 | { 3005 | return UP_HOF; /* hierarchical authorisation failed */ 3006 | } 3007 | } 3008 | } 3009 | else if ( new_object != NULL && old_object != NULL ) 3010 | { /* this is an update */ 3011 | old_mntners = get_mntners(old_object); 3012 | old_auth_vector = get_auth_vector(old_mntners); 3013 | if (old_mntners != NULL && old_auth_vector == NULL) 3014 | { 3015 | /* then, the mntners in 'old_mntners' do not exist. Problem. */ 3016 | rpsl_attr_delete_list(old_mntners); 3017 | return UP_AUF; /* auth failed */ 3018 | } 3019 | if (old_auth_vector) 3020 | { /* if we have mntners in the old object, use them */ 3021 | auth_return = authorise(old_auth_vector, credentials, overriden); 3022 | g_slist_free(old_auth_vector); 3023 | return auth_return; 3024 | } 3025 | else 3026 | { 3027 | new_mntners = get_mntners(new_object); 3028 | new_auth_vector = get_auth_vector(new_mntners); 3029 | if (new_mntners != NULL && new_auth_vector == NULL) 3030 | { 3031 | /* then, the mntners in 'new_mntners' do not exist. Problem. */ 3032 | rpsl_attr_delete_list(new_mntners); 3033 | return UP_AUF; /* auth failed */ 3034 | } 3035 | auth_return = authorise(new_auth_vector, credentials, overriden); 3036 | if (new_auth_vector) 3037 | g_slist_free(new_auth_vector); 3038 | return auth_return; 3039 | } 3040 | } 3041 | else 3042 | { /* both are NULL, mustn't happen */ 3043 | if (tracing) 3044 | { 3045 | printf("TRACING: check_auth: internal error: Both pointers are NULL\n"); 3046 | } 3047 | return UP_INT; /* internal error */ 3048 | } 3049 | } 3050 | 3051 | 3052 | /* 3053 | * Handle the "route" type 3054 | */ 3055 | else if (strcmp(type,"route") == 0) 3056 | { 3057 | if ( new_object == NULL && old_object != NULL ) 3058 | { /* the object is to be deleted */ 3059 | old_mntners = get_mntners(old_object); 3060 | old_auth_vector = get_auth_vector(old_mntners); 3061 | if (old_mntners != NULL && old_auth_vector == NULL) 3062 | { 3063 | /* then, the mntners in 'old_mntners' do not exist. Problem. */ 3064 | rpsl_attr_delete_list(old_mntners); 3065 | return UP_AUF; /* auth failed */ 3066 | } 3067 | auth_return = authorise(old_auth_vector, credentials, overriden); 3068 | g_slist_free(old_auth_vector); 3069 | return auth_return; 3070 | } 3071 | else if ( new_object != NULL && old_object == NULL ) 3072 | { /* the object is to be created */ 3073 | /* first we have to find the aut-num object mentioned in the 3074 | origin attribute */ 3075 | 3076 | aut_num_object_str = get_aut_num_object(new_object); 3077 | if (aut_num_object_str == NULL) 3078 | { 3079 | if (overriden) 3080 | { 3081 | return UP_AUTH_OK; 3082 | } 3083 | else 3084 | { 3085 | return UP_HOF; /* hierarchical authorisation failed */ 3086 | } 3087 | } 3088 | else 3089 | { /* there is a corresponding aut-num in the db */ 3090 | if (tracing) 3091 | { 3092 | printf("TRACING: check_auth: will try to authorise the route using aut-num\n"); 3093 | } 3094 | aut_num_obj = rpsl_object_init(aut_num_object_str); 3095 | if (tracing) 3096 | { 3097 | if ( rpsl_object_has_error(aut_num_obj, RPSL_ERRLVL_ERROR) ) 3098 | { 3099 | /* thre was an error during the parsing */ 3100 | name = rpsl_object_get_class(aut_num_obj); 3101 | if ( name ) 3102 | { 3103 | attr = rpsl_object_get_attr(aut_num_obj, name); 3104 | if ( attr ) 3105 | { 3106 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(attr->data) ); 3107 | if ( value ) 3108 | { 3109 | printf("TRACING: get_mnt_routes_from_list: error parsing object %s\n", value ); 3110 | free(value); 3111 | } 3112 | else 3113 | printf("TRACING: get_mnt_routes_from_list: error parsing object\n"); 3114 | 3115 | rpsl_attr_delete_list(attr); 3116 | } 3117 | } 3118 | } 3119 | } 3120 | 3121 | aut_num_maintainers = get_mnt_routes(aut_num_obj); 3122 | if (aut_num_maintainers != NULL) 3123 | { 3124 | aut_num_auth_vector = get_auth_vector(aut_num_maintainers); 3125 | if (authorise(aut_num_auth_vector, credentials, overriden) == UP_AUTH_OK) 3126 | { 3127 | aut_num_auth_OK = TRUE; 3128 | } 3129 | else 3130 | {/* authorise(aut_num_auth_vector, credentials, overriden) != UP_AUTH_OK */ 3131 | rpsl_attr_delete_list(aut_num_maintainers); 3132 | return UP_HOF; 3133 | } 3134 | } 3135 | else 3136 | {/* aut_num_maintainers is NULL */ 3137 | aut_num_maintainers = get_mnt_lowers(aut_num_obj); 3138 | if (aut_num_maintainers != NULL) 3139 | { 3140 | aut_num_auth_vector = get_auth_vector(aut_num_maintainers); 3141 | if (authorise(aut_num_auth_vector, credentials, overriden) == UP_AUTH_OK) 3142 | { 3143 | aut_num_auth_OK = TRUE; 3144 | } 3145 | else 3146 | {/* authorise(aut_num_auth_vector, credentials, overriden) != UP_AUTH_OK */ 3147 | rpsl_attr_delete_list(aut_num_maintainers); 3148 | return UP_HOF; /* hierarchical authorisation failed */ 3149 | } 3150 | } 3151 | else 3152 | {/* aut_num_maintainers is NULL */ 3153 | aut_num_maintainers = get_mntners(aut_num_obj); 3154 | if (aut_num_maintainers != NULL) 3155 | { 3156 | aut_num_auth_vector = get_auth_vector(aut_num_maintainers); 3157 | if (authorise(aut_num_auth_vector, credentials, overriden) == UP_AUTH_OK) 3158 | { 3159 | aut_num_auth_OK = TRUE; 3160 | } 3161 | else 3162 | {/* authorise(aut_num_auth_vector, credentials, overriden) != UP_AUTH_OK */ 3163 | rpsl_attr_delete_list(aut_num_maintainers); 3164 | return UP_HOF; /* hierarchical authorisation failed */ 3165 | } 3166 | } 3167 | else 3168 | {/* aut_num_maintainers is NULL */ 3169 | aut_num_auth_OK = TRUE; 3170 | } 3171 | 3172 | } 3173 | } 3174 | rpsl_object_delete(aut_num_obj); 3175 | 3176 | if (aut_num_auth_OK) 3177 | { 3178 | /* now, we have to find an exact match for this route object. 3179 | If there is no exact match object, then we will go on to find 3180 | less specific. */ 3181 | exact_match_routes_str = get_exact_match_routes(new_object); 3182 | if (exact_match_routes_str != NULL) 3183 | { 3184 | exact_match_routes_maintainers = get_mnt_routes_from_list(exact_match_routes_str); 3185 | exact_match_routes_auth_vector = get_auth_vector(exact_match_routes_maintainers); 3186 | if (exact_match_routes_maintainers != NULL && exact_match_routes_auth_vector == NULL) 3187 | { 3188 | /* then, the mntners in 'exact_match_routes_maintainers' do not exist. Problem. */ 3189 | rpsl_attr_delete_list(exact_match_routes_maintainers); 3190 | return UP_AUF; /* auth failed */ 3191 | } 3192 | if (authorise(exact_match_routes_auth_vector, credentials, overriden) == UP_AUTH_OK) 3193 | { 3194 | /* then, check mnt_bys of the route itself */ 3195 | new_mntners = get_mntners(new_object); 3196 | new_auth_vector = get_auth_vector(new_mntners); 3197 | if (new_mntners != NULL && new_auth_vector == NULL) 3198 | { 3199 | /* then, the mntners in 'new_mntners' do not exist. Problem. */ 3200 | rpsl_attr_delete_list(new_mntners); 3201 | return UP_AUF; /* auth failed */ 3202 | } 3203 | auth_return = authorise(new_auth_vector, credentials, overriden); 3204 | if (new_auth_vector) 3205 | g_slist_free(new_auth_vector); 3206 | return auth_return; 3207 | } 3208 | else 3209 | { /*authorise(exact_match_routes_auth_vector, credentials, overriden) != UP_AUTH_OK*/ 3210 | return UP_HOF; /* hierarchical authorisation failed */ 3211 | } 3212 | } 3213 | else 3214 | { /* exact_match_routes == NULL */ 3215 | /* then we have to look for less specific route objs */ 3216 | less_spec_routes_str = get_less_spec_routes(new_object); 3217 | if (less_spec_routes_str != NULL) 3218 | { 3219 | less_spec_routes_mntners = get_mnt_routes_from_list(less_spec_routes_str); 3220 | less_spec_routes_mntners = g_list_concat(less_spec_routes_mntners, 3221 | get_mnt_lowers_from_list(less_spec_routes_str)); 3222 | less_spec_routes_auth_vector = get_auth_vector(less_spec_routes_mntners); 3223 | if (less_spec_routes_mntners != NULL && less_spec_routes_auth_vector == NULL) 3224 | { 3225 | /* then, the mntners in 'less_spec_routes_mntners' do not exist. Problem. */ 3226 | rpsl_attr_delete_list(less_spec_routes_mntners); 3227 | return UP_AUF; /* auth failed */ 3228 | } 3229 | if ( less_spec_routes_mntners != NULL ) 3230 | { 3231 | if (authorise(less_spec_routes_auth_vector, credentials, overriden) == UP_AUTH_OK) 3232 | { 3233 | /* then, check mnt_bys of the route itself */ 3234 | new_mntners = get_mntners(new_object); 3235 | new_auth_vector = get_auth_vector(new_mntners); 3236 | if (new_mntners != NULL && new_auth_vector == NULL) 3237 | { 3238 | /* then, the mntners in 'new_auth_vector' do not exist. Problem. */ 3239 | rpsl_attr_delete_list(new_mntners); 3240 | return UP_AUF; /* auth failed */ 3241 | } 3242 | auth_return = authorise(new_auth_vector, credentials, overriden); 3243 | if (new_auth_vector) 3244 | g_slist_free(new_auth_vector); 3245 | return auth_return; 3246 | } 3247 | else 3248 | { /*authorise(less_spec_routes_auth_vector, credentials, overriden) != UP_AUTH_OK*/ 3249 | return UP_HOF; /* hierarchical authorisation failed */ 3250 | } 3251 | } 3252 | else 3253 | { 3254 | /* there are no mnt-routes or mnt-lower in less specific route objs */ 3255 | /* check mnt-by of less specific route objs */ 3256 | less_spec_routes_mntners = get_mntners_from_list(less_spec_routes_str); 3257 | less_spec_routes_auth_vector = get_auth_vector(less_spec_routes_mntners); 3258 | if (less_spec_routes_mntners != NULL && less_spec_routes_auth_vector == NULL) 3259 | { 3260 | /* then, the mntners in 'less_spec_routes_mntners' do not exist. Problem. */ 3261 | rpsl_attr_delete_list(less_spec_routes_mntners); 3262 | return UP_AUF; /* auth failed */ 3263 | } 3264 | if (authorise(less_spec_routes_auth_vector, credentials, overriden) == UP_AUTH_OK) 3265 | { 3266 | /* then, check mnt_bys of the route itself */ 3267 | new_mntners = get_mntners(new_object); 3268 | new_auth_vector = get_auth_vector(new_mntners); 3269 | if (new_mntners != NULL && new_auth_vector == NULL) 3270 | { 3271 | /* then, the mntners in 'new_auth_vector' do not exist. Problem. */ 3272 | rpsl_attr_delete_list(new_mntners); 3273 | return UP_AUF; /* auth failed */ 3274 | } 3275 | auth_return = authorise(new_auth_vector, credentials, overriden); 3276 | if (new_auth_vector) 3277 | g_slist_free(new_auth_vector); 3278 | return auth_return; 3279 | } 3280 | else 3281 | { /*authorise(less_spec_routes_auth_vector, credentials, overriden) != UP_AUTH_OK*/ 3282 | return UP_HOF; /* hierarchical authorisation failed */ 3283 | } 3284 | } 3285 | } 3286 | else 3287 | { /* less_spec_routes == NULL */ 3288 | /* so, we have to get the exact match inetnum */ 3289 | exact_match_inetnum_str = get_exact_match_inetnum(new_object); 3290 | if (exact_match_inetnum_str != NULL) 3291 | { 3292 | exact_match_inetnum_obj = rpsl_object_init(exact_match_inetnum_str); 3293 | if (tracing) 3294 | { 3295 | if ( rpsl_object_has_error(exact_match_inetnum_obj, RPSL_ERRLVL_ERROR) ) 3296 | { 3297 | /* thre was an error during the parsing */ 3298 | name = rpsl_object_get_class(exact_match_inetnum_obj); 3299 | if ( name ) 3300 | { 3301 | attr = rpsl_object_get_attr(exact_match_inetnum_obj, name); 3302 | if ( attr ) 3303 | { 3304 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(attr->data) ); 3305 | if ( value ) 3306 | { 3307 | printf("TRACING: get_mnt_routes_from_list: error parsing object %s\n", value ); 3308 | free(value); 3309 | } 3310 | else 3311 | printf("TRACING: get_mnt_routes_from_list: error parsing object\n"); 3312 | 3313 | rpsl_attr_delete_list(attr); 3314 | } 3315 | } 3316 | } 3317 | } 3318 | 3319 | exact_match_inetnum_mnt_routes = get_mnt_routes(exact_match_inetnum_obj); 3320 | exact_match_inetnum_mnt_bys = get_mntners(exact_match_inetnum_obj); 3321 | rpsl_object_delete(exact_match_inetnum_obj); 3322 | 3323 | exact_match_inetnum_auth_vector = get_auth_vector(exact_match_inetnum_mnt_routes); 3324 | if (exact_match_inetnum_mnt_routes != NULL && exact_match_inetnum_auth_vector == NULL) 3325 | { 3326 | /* then, the mntners in 'exact_match_inetnum_mnt_routes' do not exist. Problem. */ 3327 | rpsl_attr_delete_list(exact_match_inetnum_mnt_routes); 3328 | return UP_AUF; /* auth failed */ 3329 | } 3330 | 3331 | /* if there are mnt_routes in the exact match inetnum */ 3332 | if (exact_match_inetnum_mnt_routes != NULL) 3333 | { 3334 | if (authorise(exact_match_inetnum_auth_vector, credentials, overriden) == UP_AUTH_OK) 3335 | { 3336 | /* then, check mnt_bys of the route itself */ 3337 | new_mntners = get_mntners(new_object); 3338 | new_auth_vector = get_auth_vector(new_mntners); 3339 | if (new_mntners != NULL && new_auth_vector == NULL) 3340 | { 3341 | /* then, the mntners in 'new_auth_vector' do not exist. Problem. */ 3342 | rpsl_attr_delete_list(new_mntners); 3343 | return UP_AUF; /* auth failed */ 3344 | } 3345 | auth_return = authorise(new_auth_vector, credentials, overriden); 3346 | if (new_auth_vector) 3347 | g_slist_free(new_auth_vector); 3348 | return auth_return; 3349 | } 3350 | else 3351 | { 3352 | return UP_HOF; /* hierarchical authorisation failed */ 3353 | } 3354 | } 3355 | else 3356 | { /* if there was no mnt_routes in the exact match inetnum, then use mnt-by of it */ 3357 | exact_match_inetnum_auth_vector = get_auth_vector(exact_match_inetnum_mnt_bys); 3358 | if (exact_match_inetnum_mnt_bys != NULL && exact_match_inetnum_auth_vector == NULL) 3359 | { 3360 | /* then, the mntners in 'exact_match_inetnum_mnt_bys' do not exist. Problem. */ 3361 | rpsl_attr_delete_list(exact_match_inetnum_mnt_bys); 3362 | return UP_AUF; /* auth failed */ 3363 | } 3364 | 3365 | /* check mnt-by of exact match inetnum */ 3366 | if (authorise(exact_match_inetnum_auth_vector, credentials, overriden) == UP_AUTH_OK) 3367 | { 3368 | /* then, check mnt_bys of the route itself */ 3369 | new_mntners = get_mntners(new_object); 3370 | new_auth_vector = get_auth_vector(new_mntners); 3371 | if (new_mntners != NULL && new_auth_vector == NULL) 3372 | { 3373 | /* then, the mntners in 'new_auth_vector' do not exist. Problem. */ 3374 | rpsl_attr_delete_list(new_mntners); 3375 | return UP_AUF; /* auth failed */ 3376 | } 3377 | auth_return = authorise(new_auth_vector, credentials, overriden); 3378 | if (new_auth_vector) 3379 | g_slist_free(new_auth_vector); 3380 | return auth_return; 3381 | } 3382 | else 3383 | { 3384 | return UP_HOF; /* hierarchical authorisation failed */ 3385 | } 3386 | } 3387 | } 3388 | else 3389 | {/* exact_match_inetnum == NULL */ 3390 | /* then, we will try to find less spec inetnums */ 3391 | less_spec_inetnum_str = get_less_spec_inetnum(new_object); 3392 | if (less_spec_inetnum_str != NULL) 3393 | { 3394 | less_spec_inetnum_obj = rpsl_object_init(less_spec_inetnum_str); 3395 | if (tracing) 3396 | { 3397 | if ( rpsl_object_has_error(less_spec_inetnum_obj, RPSL_ERRLVL_ERROR) ) 3398 | { 3399 | /* thre was an error during the parsing */ 3400 | name = rpsl_object_get_class(less_spec_inetnum_obj); 3401 | if ( name ) 3402 | { 3403 | attr = rpsl_object_get_attr(less_spec_inetnum_obj, name); 3404 | if ( attr ) 3405 | { 3406 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(attr->data) ); 3407 | if ( value ) 3408 | { 3409 | printf("TRACING: get_mnt_routes_from_list: error parsing object %s\n", value ); 3410 | free(value); 3411 | } 3412 | else 3413 | printf("TRACING: get_mnt_routes_from_list: error parsing object\n"); 3414 | 3415 | rpsl_attr_delete_list(attr); 3416 | } 3417 | } 3418 | } 3419 | } 3420 | 3421 | less_spec_inetnum_mntners = get_mnt_routes(less_spec_inetnum_obj); 3422 | less_spec_inetnum_mntners = g_list_concat(less_spec_inetnum_mntners, 3423 | get_mnt_lowers(less_spec_inetnum_obj)); 3424 | less_spec_inetnum_auth_vector = get_auth_vector(less_spec_inetnum_mntners); 3425 | 3426 | less_spec_inetnum_mnt_bys = get_mntners(less_spec_inetnum_obj); 3427 | 3428 | rpsl_object_delete(less_spec_inetnum_obj); 3429 | 3430 | if (less_spec_inetnum_mntners != NULL && less_spec_inetnum_auth_vector == NULL) 3431 | { 3432 | /* then, the mntners in 'less_spec_inetnum_mntners' do not exist. Problem. */ 3433 | rpsl_attr_delete_list(less_spec_inetnum_mntners); 3434 | return UP_AUF; /* auth failed */ 3435 | } 3436 | if (less_spec_inetnum_mntners != NULL) 3437 | { /* if there are mntners in mnt-lower and/or mnt-routes */ 3438 | if (authorise(less_spec_inetnum_auth_vector, credentials, overriden) == UP_AUTH_OK) 3439 | { 3440 | /* then, check mnt_bys of the route itself */ 3441 | new_mntners = get_mntners(new_object); 3442 | new_auth_vector = get_auth_vector(new_mntners); 3443 | if (new_mntners != NULL && new_auth_vector == NULL) 3444 | { 3445 | /* then, the mntners in 'new_auth_vector' do not exist. Problem. */ 3446 | rpsl_attr_delete_list(new_mntners); 3447 | return UP_AUF; /* auth failed */ 3448 | } 3449 | auth_return = authorise(new_auth_vector, credentials, overriden); 3450 | if (new_auth_vector) 3451 | g_slist_free(new_auth_vector); 3452 | return auth_return; 3453 | } 3454 | else 3455 | { /* authorise(exact_match_auth_vector, credentials, overriden) != UP_AUTH_OK */ 3456 | return UP_HOF; /* hierarchical authorisation failed */ 3457 | } 3458 | } 3459 | else 3460 | { /* there isn't any mnt-lower or mnt-routes in the less spec inetnum */ 3461 | /* so we must use mnt-by of less spec inetum */ 3462 | less_spec_inetnum_auth_vector = get_auth_vector(less_spec_inetnum_mnt_bys); 3463 | if (less_spec_inetnum_mnt_bys != NULL && less_spec_inetnum_auth_vector == NULL) 3464 | { 3465 | /* then, the mntners in 'less_spec_inetnum_mnt_bys' do not exist. Problem. */ 3466 | 3467 | rpsl_attr_delete_list(less_spec_inetnum_mnt_bys); 3468 | return UP_AUF; /* auth failed */ 3469 | } 3470 | if (authorise(less_spec_inetnum_auth_vector, credentials, overriden) == UP_AUTH_OK) 3471 | { 3472 | /* then, check mnt_bys of the route itself */ 3473 | new_mntners = get_mntners(new_object); 3474 | new_auth_vector = get_auth_vector(new_mntners); 3475 | if (new_mntners != NULL && new_auth_vector == NULL) 3476 | { 3477 | /* then, the mntners in 'new_auth_vector' do not exist. Problem. */ 3478 | rpsl_attr_delete_list(new_mntners); 3479 | return UP_AUF; /* auth failed */ 3480 | } 3481 | auth_return = authorise(new_auth_vector, credentials, overriden); 3482 | if (new_auth_vector) 3483 | g_slist_free(new_auth_vector); 3484 | return auth_return; 3485 | } 3486 | else 3487 | { 3488 | return UP_HOF; /* hierarchical authorisation failed */ 3489 | } 3490 | } 3491 | } 3492 | else 3493 | {/* less_spec_inetnum == NULL */ 3494 | /* now that we couldn't find any route or inetnum object 3495 | to be used in authentication. So, only if the auth is 3496 | overriden the object will be created. */ 3497 | if (overriden) 3498 | { 3499 | return UP_AUTH_OK; 3500 | } 3501 | else 3502 | { 3503 | return UP_HOF; /* hierarchical authorisation failed */ 3504 | } 3505 | } 3506 | } 3507 | } 3508 | } 3509 | } 3510 | else 3511 | {/* ! aut_num_auth_OK */ 3512 | return UP_HOF; /* hierarchical auth failed */ 3513 | } 3514 | } 3515 | 3516 | } 3517 | else if ( new_object != NULL && old_object != NULL ) 3518 | { /* this is an update */ 3519 | old_mntners = get_mntners(old_object); 3520 | old_auth_vector = get_auth_vector(old_mntners); 3521 | if (old_mntners != NULL && old_auth_vector == NULL) 3522 | { 3523 | /* then, the mntners in 'old_auth_vector' do not exist. Problem. */ 3524 | rpsl_attr_delete_list(old_mntners); 3525 | return UP_AUF; /* auth failed */ 3526 | } 3527 | if (old_auth_vector) 3528 | { /* if we have mntners in the old object, use them */ 3529 | auth_return = authorise(old_auth_vector, credentials, overriden); 3530 | g_slist_free(old_auth_vector); 3531 | return auth_return; 3532 | } 3533 | else 3534 | { 3535 | new_mntners = get_mntners(new_object); 3536 | new_auth_vector = get_auth_vector(new_mntners); 3537 | if (new_mntners != NULL && new_auth_vector == NULL) 3538 | { 3539 | /* then, the mntners in 'new_auth_vector' do not exist. Problem. */ 3540 | rpsl_attr_delete_list(new_mntners); 3541 | return UP_AUF; /* auth failed */ 3542 | } 3543 | auth_return = authorise(new_auth_vector, credentials, overriden); 3544 | if (new_auth_vector) 3545 | g_slist_free(new_auth_vector); 3546 | return auth_return; 3547 | } 3548 | } 3549 | else 3550 | { /* both are NULL, mustn't happen */ 3551 | if (tracing) 3552 | { 3553 | printf("TRACING: check_auth: internal error: Both pointers are NULL\n"); 3554 | } 3555 | return UP_INT; /* internal error */ 3556 | } 3557 | } 3558 | 3559 | 3560 | /* 3561 | * Handle the set objects ("as-set","rtr-set", "peering-set", "route-set" and "filter-set" types 3562 | */ 3563 | else if (strcmp(type,"as-set") == 0 || strcmp(type,"rtr-set") == 0 || 3564 | strcmp(type,"peering-set") == 0 || strcmp(type,"filter-set") == 0 || 3565 | strcmp(type,"route-set") == 0 ) 3566 | { 3567 | if ( new_object == NULL && old_object != NULL ) 3568 | { /* the object is to be deleted */ 3569 | old_mntners = get_mntners(old_object); 3570 | old_auth_vector = get_auth_vector(old_mntners); 3571 | if (old_mntners != NULL && old_auth_vector == NULL) 3572 | { 3573 | /* then, the mntners in 'old_auth_vector' do not exist. Problem. */ 3574 | rpsl_attr_delete_list(old_mntners); 3575 | return UP_AUF; /* auth failed */ 3576 | } 3577 | auth_return = authorise(old_auth_vector, credentials, overriden); 3578 | g_slist_free(old_auth_vector); 3579 | return auth_return; 3580 | } 3581 | else if ( new_object != NULL && old_object == NULL ) 3582 | { /* the object is to be created */ 3583 | set_name = get_search_key(new_object, type); 3584 | if (strstr(set_name,":") == NULL ) 3585 | { /* if the name is _not_ hierarchical */ 3586 | new_mntners = get_mntners(new_object); 3587 | new_auth_vector = get_auth_vector(new_mntners); 3588 | if (new_mntners != NULL && new_auth_vector == NULL) 3589 | { 3590 | /* then, the mntners in 'new_auth_vector' do not exist. Problem. */ 3591 | rpsl_attr_delete_list(new_mntners); 3592 | return UP_AUF; /* auth failed */ 3593 | } 3594 | auth_return = authorise(new_auth_vector, credentials, overriden); 3595 | if (new_auth_vector) 3596 | g_slist_free(new_auth_vector); 3597 | return auth_return; 3598 | } 3599 | else 3600 | { /* the name is hierarchical */ 3601 | less_specific_object_str = get_less_specific_set(new_object, type); 3602 | if (less_specific_object_str != NULL) 3603 | { /* such an object exists */ 3604 | less_specific_obj = rpsl_object_init(less_specific_object_str); 3605 | if (tracing) 3606 | { 3607 | if ( rpsl_object_has_error(less_specific_obj, RPSL_ERRLVL_ERROR) ) 3608 | { 3609 | /* thre was an error during the parsing */ 3610 | name = rpsl_object_get_class(less_specific_obj); 3611 | if ( name ) 3612 | { 3613 | attr = rpsl_object_get_attr(less_specific_obj, name); 3614 | if ( attr ) 3615 | { 3616 | value = rpsl_attr_get_clean_value( (rpsl_attr_t *)(attr->data) ); 3617 | if ( value ) 3618 | { 3619 | printf("TRACING: get_mnt_routes_from_list: error parsing object %s\n", value ); 3620 | free(value); 3621 | } 3622 | else 3623 | printf("TRACING: get_mnt_routes_from_list: error parsing object\n"); 3624 | 3625 | rpsl_attr_delete_list(attr); 3626 | } 3627 | } 3628 | } 3629 | } 3630 | 3631 | less_specific_object_type = rpsl_object_get_class(less_specific_obj); 3632 | 3633 | if (strcmp(less_specific_object_type, "aut-num") == 0) 3634 | { /* if this is an aut-num object */ 3635 | less_specific_mnt_lowers = get_mnt_lowers(less_specific_obj); 3636 | less_specific_auth_vector = get_auth_vector(less_specific_mnt_lowers); 3637 | if (less_specific_mnt_lowers != NULL && less_specific_auth_vector == NULL) 3638 | { 3639 | /* then, the mntners in 'less_specific_auth_vector' do not exist. Problem. */ 3640 | rpsl_attr_delete_list(less_specific_mnt_lowers); 3641 | rpsl_object_delete(less_specific_obj); 3642 | return UP_AUF; /* auth failed */ 3643 | } 3644 | if (less_specific_auth_vector != NULL) 3645 | { 3646 | auth_return = authorise(less_specific_auth_vector, credentials, overriden); 3647 | free(less_specific_auth_vector); 3648 | rpsl_object_delete(less_specific_obj); 3649 | return auth_return; 3650 | } 3651 | else 3652 | { /* the less specific object doesn't contain any mnt-lower */ 3653 | less_specific_mntners = get_mntners(less_specific_obj); 3654 | less_specific_auth_vector = get_auth_vector(less_specific_mntners); 3655 | if (less_specific_mntners != NULL && less_specific_auth_vector == NULL) 3656 | { 3657 | /* then, the mntners in 'less_specific_mntners' do not exist. Problem. */ 3658 | rpsl_attr_delete_list(less_specific_mntners); 3659 | rpsl_object_delete(less_specific_obj); 3660 | return UP_AUF; /* auth failed */ 3661 | } 3662 | if (less_specific_auth_vector != NULL) 3663 | { /* less spec object has some mnt-by attribs, 3664 | use them */ 3665 | auth_return = authorise(less_specific_auth_vector, credentials, overriden); 3666 | free(less_specific_auth_vector); 3667 | rpsl_object_delete(less_specific_obj); 3668 | return auth_return; 3669 | } 3670 | else 3671 | { /* the less specific object doesn't contain any mnt-by either */ 3672 | if (overriden) 3673 | { 3674 | rpsl_object_delete(less_specific_obj); 3675 | return UP_AUTH_OK; 3676 | } 3677 | else 3678 | { 3679 | rpsl_object_delete(less_specific_obj); 3680 | return UP_HOF; /* hierarchical authorisation failed */ 3681 | } 3682 | } 3683 | } 3684 | } 3685 | else 3686 | { /* this is _not_ an aut-num object*/ 3687 | less_specific_mntners = get_mntners(less_specific_obj); 3688 | less_specific_auth_vector = get_auth_vector(less_specific_mntners); 3689 | if (less_specific_mntners != NULL && less_specific_auth_vector == NULL) 3690 | { 3691 | /* then, the mntners in 'less_specific_mntners' do not exist. Problem. */ 3692 | rpsl_attr_delete_list(less_specific_mntners); 3693 | rpsl_object_delete(less_specific_obj); 3694 | return UP_AUF; /* auth failed */ 3695 | } 3696 | if (less_specific_auth_vector != NULL ) 3697 | { /* the set obj has some mnt-by attribs */ 3698 | auth_return = authorise(less_specific_auth_vector, credentials, overriden); 3699 | free(less_specific_auth_vector); 3700 | rpsl_object_delete(less_specific_obj); 3701 | return auth_return; 3702 | } 3703 | else 3704 | { 3705 | if (overriden) 3706 | { 3707 | rpsl_object_delete(less_specific_obj); 3708 | return UP_AUTH_OK; 3709 | } 3710 | else 3711 | { 3712 | rpsl_object_delete(less_specific_obj); 3713 | return UP_HOF; /* hierarchical authorisation failed */ 3714 | } 3715 | } 3716 | } 3717 | } 3718 | else 3719 | { /* we don't have a less specific of this set object in the DB */ 3720 | return UP_HOF; /* hierarchical authorisation failed */ 3721 | } 3722 | } 3723 | } 3724 | else if ( new_object != NULL && old_object != NULL ) 3725 | { /* this is an update */ 3726 | old_mntners = get_mntners(old_object); 3727 | old_auth_vector = get_auth_vector(old_mntners); 3728 | if (old_mntners != NULL && old_auth_vector == NULL) 3729 | { 3730 | /* then, the mntners in 'old_auth_vector' do not exist. Problem. */ 3731 | rpsl_attr_delete_list(old_mntners); 3732 | return UP_AUF; /* auth failed */ 3733 | } 3734 | if (old_auth_vector) 3735 | { /* if we have mntners in the old object, use them */ 3736 | auth_return = authorise(old_auth_vector, credentials, overriden); 3737 | g_slist_free(old_auth_vector); 3738 | return auth_return; 3739 | } 3740 | else 3741 | { 3742 | new_mntners = get_mntners(new_object); 3743 | new_auth_vector = get_auth_vector(new_mntners); 3744 | if (new_mntners != NULL && new_auth_vector == NULL) 3745 | { 3746 | /* then, the mntners in 'new_mntners' do not exist. Problem. */ 3747 | rpsl_attr_delete_list(new_mntners); 3748 | return UP_AUF; /* auth failed */ 3749 | } 3750 | auth_return = authorise(new_auth_vector, credentials, overriden); 3751 | if (new_auth_vector) 3752 | g_slist_free(new_auth_vector); 3753 | return auth_return; 3754 | } 3755 | } 3756 | else 3757 | { /* both are NULL, mustn't happen */ 3758 | if (tracing) 3759 | { 3760 | printf("TRACING: check_auth: internal error: Both pointers are NULL\n"); 3761 | } 3762 | return UP_INT; /* internal error */ 3763 | } 3764 | 3765 | } 3766 | else 3767 | { /* We exhausted all object classes. If we are here, then there is a problem */ 3768 | printf("check_auth: This type '%s' is unknown\n", type); 3769 | return UP_NIY; /* not implemented yet */ 3770 | } 3771 | return UP_AUF; /* if we come to this point, then auth failed */ 3772 | } 3773 | 3774 | 3775 | 3776 | /* Gets the old version of the given "arg" object, which is in char * format 3777 | and returns the old version again in char * format */ 3778 | 3779 | char * get_old_version(rpsl_object_t *object, char * arg) 3780 | { 3781 | const char *type=NULL; 3782 | char *lctype = NULL; 3783 | char *primary_search_key = NULL, *search_string = NULL; 3784 | char *result = NULL, *origin = NULL, *nic_hdl = NULL; 3785 | 3786 | type = rpsl_object_get_class(object); 3787 | lctype = strdup(type); 3788 | g_strdown(lctype); 3789 | 3790 | primary_search_key = get_search_key(object, lctype); 3791 | if ( primary_search_key == NULL ) 3792 | { 3793 | if(tracing) 3794 | { 3795 | printf("type=%s\n", type); 3796 | printf("primary_search_key is NULL\n"); 3797 | } 3798 | return NULL; 3799 | } 3800 | 3801 | if(tracing) 3802 | { 3803 | printf("TRACING: type= %s\n", type); 3804 | printf("TRACING: primary_search_key= %s\n", primary_search_key); 3805 | } 3806 | 3807 | /* if the object is a pn or a ro object, then get all pn/ro's with the same NIC hdl */ 3808 | if ( strcmp(lctype,"person") == 0 || strcmp(lctype,"role") == 0 ) 3809 | { 3810 | /* prepare the search string */ 3811 | search_string = (char *)malloc(strlen(primary_search_key) + strlen("-x -R -r -T") 3812 | + strlen("person,role") + 2); 3813 | sprintf(search_string, "-x -R -r -Tperson,role %s", primary_search_key); 3814 | } 3815 | else 3816 | { 3817 | /* prepare the search string */ 3818 | search_string = (char *)malloc(strlen(primary_search_key) + strlen("-x -R -r -T") 3819 | + strlen(lctype) + 2); 3820 | sprintf(search_string, "-x -R -r -T%s %s",lctype, primary_search_key); 3821 | } 3822 | 3823 | result = send_and_get(query_host, query_port, search_string); 3824 | if(tracing) 3825 | { 3826 | printf("TRACING: send_and_get has returned"); 3827 | printf("TRACING: send_and_get returned with search %s result %s", search_string, result); 3828 | } 3829 | free(search_string); 3830 | free(primary_search_key); 3831 | if ( result == NULL ) 3832 | return NULL; 3833 | 3834 | /* and here, we must filter the 'result' with NIC handle */ 3835 | if ( strcmp(lctype,"person") == 0 ) 3836 | { 3837 | if(tracing) 3838 | { 3839 | printf("TRACING: This is a person\n"); 3840 | } 3841 | /* if this is a person, then we must filter out the persons with different 3842 | nic-hdl attributes (since it is possible to have this NIC hdl in the name 3843 | of a person object, and whois will return that object too) */ 3844 | nic_hdl = get_search_key(object, "nic-hdl"); 3845 | if(tracing) 3846 | { 3847 | printf("TRACING: Got nic-hdl of person: %s\n", nic_hdl); 3848 | } 3849 | result = up_filter_out_diff_nichdls(result, nic_hdl); 3850 | if(tracing) 3851 | { 3852 | printf("TRACING: Filtered person\n"); 3853 | } 3854 | free(nic_hdl); 3855 | } 3856 | 3857 | /* also, we must filter the 'result' with NIC handle for roles */ 3858 | if(strcmp(type,"role") == 0) 3859 | { 3860 | if(tracing) 3861 | { 3862 | printf("TRACING: This is a role\n"); 3863 | } 3864 | /* if this is a role, then we must filter out the roles with different 3865 | nic-hdl attributes (since it is possible to have this NIC hdl in the name 3866 | of a role object, and whois will return that object too) */ 3867 | nic_hdl = get_search_key(object, "nic-hdl"); 3868 | if(tracing) 3869 | { 3870 | printf("TRACING: Got nic-hdl of role: %s\n", nic_hdl); 3871 | } 3872 | result = up_filter_out_diff_nichdls(result, nic_hdl); 3873 | if(tracing) 3874 | { 3875 | printf("TRACING: Filtered role\n"); 3876 | } 3877 | free(nic_hdl); 3878 | } 3879 | 3880 | if(strcmp(type,"route") == 0) 3881 | { 3882 | if(tracing) 3883 | { 3884 | printf("TRACING: This is a route\n"); 3885 | } 3886 | /* if this is a route, then we must filter out the routes with different 3887 | origin attributes */ 3888 | origin = get_search_key(object, "origin"); 3889 | if(tracing) 3890 | { 3891 | printf("TRACING: Got origin of route: %s\n", origin); 3892 | } 3893 | result = up_filter_out_diff_origins(result, origin); 3894 | if(tracing) 3895 | { 3896 | printf("TRACING: Filtered routes\n"); 3897 | } 3898 | free(origin); 3899 | } 3900 | 3901 | /* count the objects */ 3902 | if(count_objects(result) == 0) 3903 | { 3904 | result = NULL; /* we don't have such an object */ 3905 | } 3906 | else if(count_objects(result) == 1) 3907 | { 3908 | result = take_object(result); 3909 | if(tracing) 3910 | { 3911 | printf("TRACING: Take_object returned ***%s\n", result); 3912 | } 3913 | } 3914 | else 3915 | { /* we have more than one objects, error! */ 3916 | result = NULL; 3917 | } 3918 | 3919 | return result; 3920 | } 3921 | 3922 | 3923 | 3924 | 3925 | /* Gets a credentials_struct whose 'from' field will be filled in and 3926 | the mail header. Finds the 'From:' line in the header and sets 3927 | the 'from' field to this line (all line, including the 'From:' string, 3928 | since some users have put regexps which match the whole line in their 3929 | 'auth' attributes.) */ 3930 | void process_mail_header(credentials_struct * credentials_ptr, char * arg) 3931 | { 3932 | char * header = strdup(arg); 3933 | char * temp = (char *)malloc(strlen(header)); 3934 | 3935 | while (index(header, '\n') != NULL) 3936 | { 3937 | temp = strdup(header); 3938 | temp[index(temp, '\n') - temp] = '\0'; 3939 | if (strstr(temp, "From:") == temp) 3940 | { 3941 | if (tracing) 3942 | { 3943 | printf("TRACING: process_mail_header: Assigning %s\n", temp); 3944 | } 3945 | credentials_ptr->from = strdup(temp); 3946 | free(temp); 3947 | return; 3948 | } 3949 | header = header + (index(header, '\n') - header + 1); 3950 | } 3951 | free(temp); 3952 | } 3953 | 3954 | 3955 | 3956 | void up_string_pack(char *dest, const char *source) 3957 | { 3958 | if(tracing) 3959 | { 3960 | printf("TRACING: up_string_pack running\n"); 3961 | } 3962 | 3963 | /*----------------------------------------------------------------------*\ 3964 | 3965 | * Function to rewrite a line of text with only one blankspace between * 3966 | * each word. 3967 | * 3968 | \*----------------------------------------------------------------------*/ 3969 | /* 3970 | * This while loop continues until the NULL character is copied into 3971 | * the destination string. If a tab character is copied into the 3972 | * destination string, it is replaced with a blank-space character. 3973 | * 3974 | * Multiple blank-space and/or tab characters are skipped in the source 3975 | * string until any other character is found. 3976 | */ 3977 | 3978 | while (1) 3979 | { 3980 | *dest = *source; 3981 | 3982 | if (*dest == '\t') 3983 | (*dest = ' '); 3984 | 3985 | /* Exit if have copied the end of the string. */ 3986 | if (*dest == '\0') 3987 | return; 3988 | 3989 | /* 3990 | * If the source character was a blank-space or a tab, move to the next 3991 | * source character. While the source character is a blank-space or a 3992 | * tab, move to the next character (i.e. ignore these characters). When 3993 | * any other character is found in the source string, move to the next 3994 | * element of the destination string. 3995 | * 3996 | * Otherwise, simultaneously, move to the next elements of the destination 3997 | * and the source strings. 3998 | */ 3999 | 4000 | if ( (*source == ' ') || (*source == '\t') ) 4001 | { 4002 | ++source; 4003 | while ( (*source == ' ') || (*source == '\t') ) 4004 | { 4005 | ++source; 4006 | } 4007 | 4008 | ++dest; 4009 | } 4010 | else 4011 | { 4012 | ++dest; 4013 | ++source; 4014 | } 4015 | } 4016 | } 4017 | 4018 | 4019 | /* replaces the erase_str occurences with insert_str in str (which is a ptr to GString) */ 4020 | char * UP_replace_strings(char * str, const char * erase_str, const char * insert_str) 4021 | { 4022 | GString * g_str; 4023 | int pos; 4024 | char * result_str; 4025 | 4026 | /* erase_str mustn't be NULL */ 4027 | assert(erase_str != NULL); 4028 | 4029 | /* if insert str is NULL, make it empty string */ 4030 | if(insert_str == NULL) 4031 | { 4032 | insert_str = strdup(""); 4033 | } 4034 | 4035 | g_str = g_string_new(str); 4036 | 4037 | /* replace erase_str with insert_str */ 4038 | while(strstr(g_str->str, erase_str) != NULL) 4039 | { 4040 | pos = strstr(g_str->str, erase_str) - g_str->str; 4041 | g_str = g_string_erase(g_str, pos, strlen(erase_str)); 4042 | if(insert_str != NULL) 4043 | { 4044 | g_str = g_string_insert(g_str, pos, insert_str); 4045 | } 4046 | } 4047 | 4048 | /* save the result string */ 4049 | result_str = strdup(g_str->str); 4050 | 4051 | /* free the GString structure (TRUE means 'also free the char string') */ 4052 | g_string_free(g_str, TRUE); 4053 | 4054 | return result_str; 4055 | } 4056 | 4057 | 4058 | 4059 | /* replaces the erase_str occurences with insert_str in g_str (which is a ptr to GString) */ 4060 | GString * UP_replace_GStrings(GString * g_str, const char * erase_str, const char * insert_str) 4061 | { 4062 | int pos; 4063 | 4064 | if (insert_str == NULL) 4065 | { /* then don't do anything */ 4066 | return g_str; 4067 | } 4068 | 4069 | /* replace erase_str with insert_str */ 4070 | while (strstr(g_str->str, erase_str) != NULL) 4071 | { 4072 | pos = strstr(g_str->str, erase_str) - g_str->str; 4073 | g_str = g_string_erase(g_str, pos, strlen(erase_str)); 4074 | g_str = g_string_insert(g_str, pos, insert_str); 4075 | } 4076 | return g_str; 4077 | } 4078 | 4079 | 4080 | 4081 | /* looks if two objects are identical or not. 4082 | Takes two objects, one as char *, the other as 4083 | a parsed object, and returns 1 if 4084 | they are identical, returns 0 if not. 4085 | 4086 | Algorithm is very simple: All strings of tabs and 4087 | white spaces are collapsed into a single white space, 4088 | and then the strings are compared (strcmp) */ 4089 | int identical(const char * old_version, rpsl_object_t *object) 4090 | { 4091 | char * arg1 = strdup(old_version); 4092 | char * arg2 = NULL; 4093 | rpsl_object_t *object2; 4094 | rpsl_error_t error; 4095 | int result = 0; 4096 | char *temp1, *temp2; 4097 | char *temp; 4098 | 4099 | object2 = rpsl_object_copy(object); 4100 | rpsl_object_remove_attr_name(object2, "delete", &error); 4101 | rpsl_object_remove_attr_name(object2, "override", &error); 4102 | arg2 = rpsl_object_get_text(object2,RPSL_STD_COLUMN); 4103 | 4104 | arg1 = g_strstrip(arg1); 4105 | arg2 = g_strstrip(arg2); 4106 | 4107 | /* convert tabs to white spaces */ 4108 | arg1 = g_strdelimit(arg1, "\t", ' '); 4109 | arg2 = g_strdelimit(arg2, "\t", ' '); 4110 | 4111 | temp1 = (char *)malloc(strlen(arg1) + 1); 4112 | temp2 = (char *)malloc(strlen(arg2) + 1); 4113 | up_string_pack(temp1, arg1); 4114 | up_string_pack(temp2, arg2); 4115 | 4116 | /* if there are still \r's at the end of strings, remove them */ 4117 | if((temp1[strlen(temp1) - 1]) == '\r') 4118 | { 4119 | temp1[strlen(temp1) - 1] = '\0'; 4120 | } 4121 | if((temp2[strlen(temp2) - 1]) == '\r') 4122 | { 4123 | temp2[strlen(temp2) - 1] = '\0'; 4124 | } 4125 | 4126 | /* there may be white spaces at the end of the strings now, remove them */ 4127 | if((temp1[strlen(temp1) - 1]) == ' ') 4128 | { 4129 | temp1[strlen(temp1) - 1] = '\0'; 4130 | } 4131 | if((temp2[strlen(temp2) - 1]) == ' ') 4132 | { 4133 | temp2[strlen(temp2) - 1] = '\0'; 4134 | } 4135 | 4136 | /* remove the white spaces just before the EOLs (since this is not taken care of by 4137 | the up_string_pack func) */ 4138 | temp = UP_replace_strings(temp1, " \n", "\n"); 4139 | free(temp1); 4140 | temp1 = temp; 4141 | 4142 | temp = UP_replace_strings(temp2, " \n", "\n"); 4143 | free(temp2); 4144 | temp2 = temp; 4145 | 4146 | result = strcmp(temp1, temp2); 4147 | if(tracing){ 4148 | printf("TRACING: identical: the objects are:\n[%s]\n[%s]\n", temp1, temp2); 4149 | printf("TRACING: identical: the lengths are:\n[%i]\n[%i]\n", strlen(temp1), strlen(temp2)); 4150 | } 4151 | free(arg1); 4152 | free(arg2); 4153 | free(temp1); 4154 | free(temp2); 4155 | if(result == 0) 4156 | { 4157 | if(tracing) 4158 | { 4159 | printf("TRACING: identical returning 1\n"); 4160 | } 4161 | return 1; 4162 | } 4163 | else 4164 | { 4165 | if(tracing) 4166 | { 4167 | printf("TRACING: identical returning 0\n"); 4168 | } 4169 | return 0; 4170 | } 4171 | } 4172 | 4173 | 4174 | /* constructs an initials string from a given name (for NIC hdl generation) */ 4175 | char * find_initials(const char * person_role_name) 4176 | { 4177 | char * temp, *pos; 4178 | char * initials = NULL; 4179 | int len, i; 4180 | char ** vector; 4181 | 4182 | temp = strdup(person_role_name); 4183 | if ((pos = index(temp, '#')) != NULL) 4184 | { /* delete the EOL comment */ 4185 | pos[0] = '\0'; 4186 | } 4187 | 4188 | vector = g_strsplit(temp, " ", 0); 4189 | for (i = 0; vector[i] != NULL && i < 4; i++) 4190 | { 4191 | if ( (strlen(vector[i]) > 0 ) && isalpha( (int)(vector[i][0]) ) ) 4192 | { 4193 | if (initials == NULL) 4194 | { 4195 | initials = (char *)malloc(2); 4196 | initials[0] = vector[i][0]; 4197 | initials[1] = '\0'; 4198 | } 4199 | else 4200 | { 4201 | len = strlen(initials); 4202 | initials = (char *)realloc(initials, len + 2 ); 4203 | initials[len] = vector[i][0]; 4204 | initials[len + 1] = '\0'; 4205 | } 4206 | } 4207 | } 4208 | free(temp); 4209 | g_strfreev(vector); 4210 | return initials; 4211 | } 4212 | 4213 | 4214 | 4215 | 4216 | /* Gets the letter combination to be used in the automatically 4217 | generated NIc handle. It the letter combination is specified 4218 | in the AUTO NIC handle, return that. If not, return NULL 4219 | (in which case the initials of the name must be used) */ 4220 | char * get_combination_from_autonic(const char * autonic) 4221 | { 4222 | GString * temp; 4223 | char * str = NULL; 4224 | char * pos; 4225 | 4226 | temp = g_string_new(autonic); 4227 | temp = g_string_up(temp); 4228 | if ((pos = index(temp->str, '#')) != NULL) 4229 | { 4230 | /* delete the EOL comment */ 4231 | pos[0] = '\0'; 4232 | } 4233 | g_strstrip(temp->str); 4234 | temp->len = strlen(temp->str);/* we directly played with temp->str, so adjust temp->len accordingly */ 4235 | 4236 | temp = g_string_erase(temp, 0, strlen("AUTO-")); 4237 | /* delete all digits from the beginning of the string */ 4238 | while (temp->len > 0 && ((temp->str)[0] >= '0' && (temp->str)[0] <= '9')) 4239 | { 4240 | temp = g_string_erase(temp, 0, 1); 4241 | } 4242 | 4243 | if (temp->len < 2 ) 4244 | { 4245 | g_string_free(temp, TRUE); 4246 | return NULL; 4247 | } 4248 | else 4249 | { 4250 | str = temp->str; 4251 | g_string_free(temp, FALSE); 4252 | g_strup(str); 4253 | if(strlen(str) > 4) 4254 | { 4255 | str[4] = '\0'; 4256 | } 4257 | return str; 4258 | } 4259 | } 4260 | 4261 | 4262 | 4263 | 4264 | /* Gets an object whose NIC hdl is an auto NIC handle and to be modified (to be sent to RIPupdate) 4265 | and modifies the nic-hdl: attribute. 4266 | For example, "nic-hdl: AUTO-1" becomes "nic-hdl: HG*-RIPE . Also, 4267 | auto_nic is set to "AUTO-1" 4268 | auto_nic must be allocated enough memory before replace_AUTO_NIC_hdl called */ 4269 | rpsl_object_t * replace_AUTO_NIC_hdl(rpsl_object_t *object, char * auto_nic_hdl) 4270 | { 4271 | GList *nichdl_item; 4272 | rpsl_object_t *object2 = NULL; 4273 | rpsl_attr_t *attr; 4274 | GList *class_attr; 4275 | char * person_role_name = NULL; 4276 | char * initials = NULL; 4277 | char *value, *new_value = NULL; 4278 | const char *type; 4279 | int pos; 4280 | 4281 | if (tracing) 4282 | { 4283 | printf("TRACING: replace_AUTO_NIC_hdl running\n"); 4284 | } 4285 | 4286 | nichdl_item = rpsl_object_get_attr(object, "nic-hdl"); /* list with one item only */ 4287 | 4288 | value = rpsl_attr_get_clean_value((rpsl_attr_t *)(nichdl_item->data)); 4289 | g_strdown(value); 4290 | if (tracing) 4291 | { 4292 | printf("TRACING: auto nic-hdl value is [%s]\n", value); 4293 | } 4294 | 4295 | if (strstr(value, "auto-") != NULL) 4296 | { 4297 | /* this attribute must be replaced with a new attribute containing a nic-hdl */ 4298 | strcpy(auto_nic_hdl, value); 4299 | pos = rpsl_attr_get_ofs((rpsl_attr_t *)(nichdl_item->data)); 4300 | 4301 | if (tracing) 4302 | { 4303 | printf("TRACING: pos [%d]\n", pos); 4304 | } 4305 | 4306 | /* if the letter combination is already specified, get it */ 4307 | initials = get_combination_from_autonic(auto_nic_hdl); 4308 | /* if the letter combination is not in the AUTO nichdl, obtain it from the name */ 4309 | if(initials == NULL) 4310 | { 4311 | type = rpsl_object_get_class(object); 4312 | class_attr = rpsl_object_get_attr(object, type); 4313 | person_role_name = rpsl_attr_get_clean_value((rpsl_attr_t *)(class_attr->data)); 4314 | rpsl_attr_delete_list(class_attr); 4315 | initials = find_initials(person_role_name); 4316 | free(person_role_name); 4317 | } 4318 | if (tracing) 4319 | { 4320 | printf("TRACING: initials [%s]\n", initials ? initials : "NULL"); 4321 | } 4322 | 4323 | object2 = rpsl_object_copy(object); 4324 | new_value = (char *)malloc(strlen(initials) + strlen(sources[0]) + 3); 4325 | strcpy(new_value, initials); 4326 | strcat(new_value, "*-"); 4327 | strcat(new_value, sources[0]); 4328 | if (tracing) 4329 | { 4330 | printf("TRACING: new_value [%s]\n", new_value); 4331 | } 4332 | 4333 | /* now copy original attribute, replace value, remove old attr and add replacement */ 4334 | attr = rpsl_attr_copy((rpsl_attr_t *)(nichdl_item->data)); 4335 | rpsl_attr_replace_value(attr, new_value); 4336 | free(initials); 4337 | free(new_value); 4338 | free(value); 4339 | 4340 | /* remove the attribute with the auto- */ 4341 | rpsl_object_remove_attr(object2, pos, NULL); 4342 | 4343 | /* insert new attribute with nic-hdl */ 4344 | rpsl_object_add_attr(object2, attr, pos, NULL); 4345 | } 4346 | rpsl_attr_delete_list(nichdl_item); 4347 | 4348 | return(object2); 4349 | } 4350 | 4351 | 4352 | 4353 | 4354 | /* replaces the refs to AUTO NIC hdls with the assigned one */ 4355 | 4356 | char * replace_refs_to_AUTO_NIC_hdl(rpsl_object_t *object, GHashTable * auto_nic_hash, char *arg) 4357 | { 4358 | char * nic_hdl = NULL; 4359 | char *name; 4360 | char *value; 4361 | char *return_str; 4362 | char *tempstr; 4363 | rpsl_attr_t *attr; 4364 | const GList * attr_list = NULL; 4365 | const GList * list_item = NULL; 4366 | int pos; 4367 | 4368 | if(tracing) 4369 | { 4370 | printf("TRACING: replace_refs_to_AUTO_NIC_hdl is running: arg:[%s]\n", arg ? arg : "NULL"); 4371 | } 4372 | 4373 | attr_list = rpsl_object_get_all_attr(object); 4374 | 4375 | // for (list_item = attr_list; list_item != NULL; list_item = g_list_next(list_item )) 4376 | // { 4377 | list_item = attr_list; 4378 | while (list_item != NULL) 4379 | { 4380 | name = strdup(rpsl_attr_get_name((rpsl_attr_t *)(list_item->data))); 4381 | g_strdown(name); 4382 | value = rpsl_attr_get_clean_value((rpsl_attr_t *)(list_item->data)); 4383 | g_strdown(value); 4384 | pos = rpsl_attr_get_ofs((rpsl_attr_t *)(list_item->data)); 4385 | if ( strstr(name, "admin-c") == name 4386 | || strstr(name, "tech-c") == name 4387 | || strstr(name, "zone-c") == name 4388 | || strstr(name, "author") == name ) 4389 | { 4390 | /* attr starts with admin-c, tech-c, zone-c or author */ 4391 | if ( strstr(value, "auto-") != NULL) 4392 | { 4393 | if(tracing) 4394 | { 4395 | printf("TRACING: replace_refs_to_AUTO_NIC_hdl: auto_nic is [%s]\n", value); 4396 | } 4397 | 4398 | /* if we have this AUTO NIC hdl in the hash, put it in. */ 4399 | if( (nic_hdl = (char *)g_hash_table_lookup(auto_nic_hash, value)) ) 4400 | { 4401 | if(tracing) 4402 | { 4403 | printf("TRACING: replace_refs_to_AUTO_NIC_hdl: nic_hdl is [%s]\n", nic_hdl); 4404 | } 4405 | /* create a new attribute with the auto nic handle */ 4406 | attr = rpsl_attr_copy((rpsl_attr_t *)(list_item->data)); 4407 | rpsl_attr_replace_value(attr, nic_hdl); 4408 | 4409 | /* remove the attribute with the auto- */ 4410 | rpsl_object_remove_attr(object, pos, NULL); 4411 | 4412 | /* insert new attribute with nic-hdl */ 4413 | rpsl_object_add_attr(object, attr, pos, NULL); 4414 | 4415 | /* replacing the attr destroys the list, so start the list again */ 4416 | attr_list = rpsl_object_get_all_attr(object); 4417 | list_item = attr_list; 4418 | } 4419 | else 4420 | { /* else, return 0 immediately */ 4421 | free(name); 4422 | free (value); 4423 | return NULL; 4424 | } 4425 | } 4426 | } 4427 | 4428 | free(name); 4429 | free (value); 4430 | 4431 | list_item = g_list_next(list_item); 4432 | } 4433 | 4434 | return_str = rpsl_object_get_text(object,RPSL_STD_COLUMN); 4435 | 4436 | /* now, if we don't have a '\n' at the end of the return_str string, we will 4437 | add one, since RAToolSet parser cannot deal with objects without a '\n' at the end */ 4438 | if(return_str[strlen(return_str) - 1] != '\n') 4439 | { 4440 | /* so, add a '\n' */ 4441 | tempstr = (char *)malloc(strlen(return_str) + 2); 4442 | sprintf(tempstr, "%s\n", return_str); 4443 | free(return_str); 4444 | return_str = tempstr; 4445 | } 4446 | 4447 | if (tracing) 4448 | { 4449 | printf("TRACING: replace_refs_to_AUTO_NIC_hdl is returning,\nreturn_str=[%s]\n", return_str); 4450 | } 4451 | 4452 | return return_str; 4453 | } 4454 | 4455 | 4456 | 4457 | 4458 | /* UP_put_assigned_NIC will replace the auto NIC handle of the object with its 4459 | assigned NIC handle and return an amended copy of the object */ 4460 | rpsl_object_t * UP_put_assigned_NIC(rpsl_object_t *object, char * assigned_NIC) 4461 | { 4462 | rpsl_object_t *object2; 4463 | rpsl_attr_t *attr; 4464 | GList * nichdl_item; 4465 | char *value; 4466 | int pos; 4467 | 4468 | nichdl_item = rpsl_object_get_attr(object, "nic-hdl"); /* a list with only one item */ 4469 | 4470 | value = rpsl_attr_get_clean_value((rpsl_attr_t *)(nichdl_item->data)); 4471 | g_strdown(value); 4472 | if (strstr(value, "auto-") != NULL) 4473 | { 4474 | /* replace the AUTO-NIC hdl with the assigned one */ 4475 | 4476 | if (tracing) 4477 | { 4478 | printf("TRACING: UP_put_assigned_NIC: auto_nic is [%s]\n", value); 4479 | } 4480 | 4481 | object2 = rpsl_object_copy(object); 4482 | /* now copy original attribute, replace value, remove old attr and add replacement */ 4483 | attr = rpsl_attr_copy((rpsl_attr_t *)(nichdl_item->data)); 4484 | rpsl_attr_replace_value(attr, assigned_NIC); 4485 | pos = rpsl_attr_get_ofs((rpsl_attr_t *)(nichdl_item->data)); 4486 | 4487 | /* remove the attribute with the auto- */ 4488 | rpsl_object_remove_attr(object2, pos, NULL); 4489 | 4490 | /* insert new attribute with nic-hdl */ 4491 | rpsl_object_add_attr(object2, attr, pos, NULL); 4492 | } 4493 | rpsl_attr_delete_list(nichdl_item); 4494 | 4495 | return object2; 4496 | } 4497 | 4498 | 4499 | 4500 | 4501 | /* Takes a parsed object, and returns 1 if this object has 4502 | an AUTO NIC handle. Otherwise, returns 0 */ 4503 | int has_AUTO_NIC_hdl(const rpsl_object_t * object) 4504 | { 4505 | GList *attributes = NULL; 4506 | 4507 | if ( !rpsl_object_is_deleted(object) ) 4508 | { 4509 | attributes = rpsl_object_get_attr(object, "nic-hdl"); 4510 | if (attributes != NULL) 4511 | { 4512 | if (strstr_in_attr_list(attributes, "AUTO-") == 1) 4513 | { /* if it contains a ref to AUTO nic */ 4514 | rpsl_attr_delete_list(attributes); 4515 | return 1; 4516 | } 4517 | } 4518 | /* if control reaches here, then we will return 0 */ 4519 | rpsl_attr_delete_list(attributes); 4520 | return 0; 4521 | } 4522 | else 4523 | { /* it doesn't pass syntax check. So, it doesn't matter if 4524 | it contains refs to AUTO NIC hdls. */ 4525 | return 0; 4526 | } 4527 | } 4528 | 4529 | 4530 | /* Takes an rpsl_object_t structure , and returns 1 if this object contains 4531 | a reference to an AUTO NIC handle. Otherwise, returns 0 */ 4532 | int has_ref_to_AUTO_nic_hdl(rpsl_object_t *object) 4533 | { 4534 | GList * attributes = NULL; 4535 | 4536 | if (! rpsl_object_is_deleted(object) ) 4537 | { 4538 | attributes = rpsl_object_get_attr(object, "admin-c"); 4539 | if (attributes != NULL) 4540 | { 4541 | if (strstr_in_attr_list(attributes, "AUTO-") == 1) 4542 | { /* if it contains a ref to AUTO nic */ 4543 | rpsl_attr_delete_list(attributes); 4544 | return 1; 4545 | } 4546 | } 4547 | rpsl_attr_delete_list(attributes); 4548 | attributes = rpsl_object_get_attr(object, "tech-c"); 4549 | if (attributes != NULL) 4550 | { 4551 | if (strstr_in_attr_list(attributes, "AUTO-") == 1) 4552 | { /* if it contains a ref to AUTO nic */ 4553 | rpsl_attr_delete_list(attributes); 4554 | return 1; 4555 | } 4556 | } 4557 | 4558 | rpsl_attr_delete_list(attributes); 4559 | attributes = rpsl_object_get_attr(object, "zone-c"); 4560 | if (attributes != NULL) 4561 | { 4562 | if(strstr_in_attr_list(attributes, "AUTO-") == 1) 4563 | { /* if it contains a ref to AUTO nic */ 4564 | rpsl_attr_delete_list(attributes); 4565 | return 1; 4566 | } 4567 | } 4568 | rpsl_attr_delete_list(attributes); 4569 | attributes = rpsl_object_get_attr(object, "author"); 4570 | if (attributes != NULL) 4571 | { 4572 | if (strstr_in_attr_list(attributes, "AUTO-") == 1) 4573 | { /* if it contains a ref to AUTO nic */ 4574 | rpsl_attr_delete_list(attributes); 4575 | return 1; 4576 | } 4577 | } 4578 | rpsl_attr_delete_list(attributes); 4579 | /* if control reaches here, then we will return 0 */ 4580 | return 0; 4581 | } 4582 | else 4583 | { /* it doesn't pass syntax check. So, it doesn't matter if 4584 | it contains refs to AUTO NIC hdls. */ 4585 | return 0; 4586 | } 4587 | } 4588 | 4589 | 4590 | 4591 | /* Gets the "From" line of the incoming mail message and finds out an 4592 | address to send the acknowledgement */ 4593 | char * find_email_address(const char * from_line) 4594 | { 4595 | char * pos1 = NULL, * pos2 = NULL, * pos = NULL; 4596 | char * temp = NULL; 4597 | char * part1 = NULL, * part2 = NULL; 4598 | 4599 | if (from_line == NULL) 4600 | { 4601 | return NULL; 4602 | } 4603 | if (strstr(from_line, "From:") != from_line) 4604 | { 4605 | temp = strdup(from_line); 4606 | } 4607 | else 4608 | { 4609 | temp = strdup(from_line + strlen("From:")); 4610 | } 4611 | g_strstrip(temp); 4612 | if (index(temp, '<')) 4613 | { /* then the line is something like '"John White" <john@inter.net>' */ 4614 | pos1 = index(temp, '<'); 4615 | pos2 = index(temp, '>'); 4616 | temp = strncpy(temp, pos1 + 1, pos2 - pos1 -1); 4617 | temp[pos2 - pos1 - 1] = '\0'; 4618 | if (tracing) 4619 | { 4620 | printf("TRACING: find_email_address temp=[%s]\n", temp); 4621 | } 4622 | } 4623 | 4624 | /* and now, we have to remove the parts in parantheses */ 4625 | while ( index(temp, '(') != NULL && index(temp, ')') != NULL 4626 | && index(temp, '(') < index(temp, ')') ) 4627 | { 4628 | part1 = strdup(temp); 4629 | /* terminate the string */ 4630 | pos = index(part1, '('); 4631 | *pos = '\0'; 4632 | 4633 | part2 = strdup(index(temp, ')') + 1); 4634 | strcat(part1, part2); 4635 | free(temp); 4636 | temp = strdup(part1); 4637 | free(part1); 4638 | free(part2); 4639 | } 4640 | 4641 | g_strstrip(temp); 4642 | return temp; 4643 | } 4644 | 4645 | 4646 | 4647 | /* removes the '\n's and '\r's at the end of the arg, and returns it */ 4648 | char * UP_remove_EOLs(char * arg) 4649 | { 4650 | while ( strlen(arg) > 0 && 4651 | (arg[strlen(arg) - 1] == '\n' || 4652 | arg[strlen(arg) - 1] == '\r') ) 4653 | { 4654 | arg[strlen(arg) - 1] = '\0'; 4655 | } 4656 | 4657 | return arg; 4658 | } 4659 | 4660 | 4661 | 4662 | /* Duplicates the given arg, and replaces 4663 | $FROM, 4664 | $SUBJECT, 4665 | $MDATE, 4666 | $MSGID, 4667 | $CC, 4668 | $HUMAILBOX 4669 | $AUTOBOX 4670 | $FROMHOST 4671 | 4672 | and $TIME & $DATE 4673 | 4674 | strings with the corresponding variables. 4675 | 4676 | */ 4677 | char * UP_replace_globals(const char * arg) 4678 | { 4679 | GString * g_str; 4680 | char * to_be_returned; 4681 | time_t cur_time; 4682 | char * temp, * time_str, * date_str; 4683 | 4684 | 4685 | /* get time */ 4686 | cur_time = time(NULL); 4687 | temp = strdup(ctime(&cur_time)); 4688 | /* temp is now something like "Fri Sep 13 00:00:00 1986\n\0", fields are const width */ 4689 | 4690 | time_str = (char *)malloc(9); 4691 | time_str = strncpy(time_str, temp + 11, 8); 4692 | time_str[8] = '\0'; 4693 | 4694 | date_str = (char *)malloc(16); 4695 | date_str = strncpy(date_str, temp, 11); 4696 | date_str[11] = '\0'; 4697 | date_str = strncat(date_str, temp + 20, 4); 4698 | 4699 | 4700 | free(temp); 4701 | 4702 | g_str = g_string_new(arg); 4703 | 4704 | g_str = UP_replace_GStrings(g_str, "$TIME", time_str); 4705 | 4706 | g_str = UP_replace_GStrings(g_str, "$DATE", date_str); 4707 | 4708 | g_str = UP_replace_GStrings(g_str, "$SUBJECT", update_mail_subject); 4709 | 4710 | g_str = UP_replace_GStrings(g_str, "$FROM", update_mail_sender); 4711 | 4712 | g_str = UP_replace_GStrings(g_str, "$MDATE", update_mail_date); 4713 | 4714 | g_str = UP_replace_GStrings(g_str, "$MSGID", update_mail_ID); 4715 | 4716 | if (update_mail_cc == NULL) 4717 | g_str = UP_replace_GStrings(g_str, "$CC", ""); 4718 | else 4719 | g_str = UP_replace_GStrings(g_str, "$CC", update_mail_cc); 4720 | 4721 | g_str = UP_replace_GStrings(g_str, "$HUMAILBOX", humailbox); 4722 | 4723 | g_str = UP_replace_GStrings(g_str, "$AUTOBOX", autobox); 4724 | 4725 | g_str = UP_replace_GStrings(g_str, "$FROMHOST", netupdclientIP); 4726 | 4727 | g_str = UP_replace_GStrings(g_str, "$HEADERTYPE", header_type); 4728 | 4729 | g_str = UP_replace_GStrings(g_str, "$TEXTTYPE", text_type); 4730 | 4731 | free(time_str); 4732 | free(date_str); 4733 | 4734 | to_be_returned = strdup(g_str->str); 4735 | g_string_free(g_str, 1); 4736 | return to_be_returned; 4737 | } 4738 | 4739 | 4740 | 4741 | 4742 | /* Adds the given file to the update log */ 4743 | void UP_add_to_upd_log(const char * filename) 4744 | { 4745 | time_t now; 4746 | struct tm * tmstr; 4747 | time_t cur_time; 4748 | char * time_str; 4749 | char datestr[10]; 4750 | char * updlogfile; 4751 | FILE * infile, * log_file; 4752 | char buf[1024]; 4753 | 4754 | 4755 | if (( infile = fopen(filename, "r")) == NULL) 4756 | { 4757 | fprintf(stderr, "UP_add_to_upd_log: Can't open upd file, %s\n", filename); 4758 | return; 4759 | } 4760 | 4761 | /* We need to get the a date string to construct the updlog file name */ 4762 | time(&now); 4763 | tmstr = localtime(&now); 4764 | strftime(datestr, 10, "%Y%m%d", tmstr); 4765 | 4766 | /* now that we have the date string, we can construct updlog file name */ 4767 | updlogfile = (char *)malloc(strlen(updlog) + strlen(datestr) + 2); 4768 | snprintf(updlogfile, strlen(updlog) + strlen(datestr) + 2, 4769 | "%s.%s", updlog, datestr); 4770 | 4771 | 4772 | if (( log_file = fopen(updlogfile, "a")) == NULL) 4773 | { 4774 | fprintf(stderr, "UP_add_to_upd_log: Can't open upd log file, %s\n", updlogfile); 4775 | free(updlogfile); 4776 | return; 4777 | } 4778 | 4779 | /* get time */ 4780 | cur_time = time(NULL); 4781 | time_str = strdup(ctime(&cur_time)); 4782 | /* cut the '\n' at the end */ 4783 | time_str[strlen(time_str) - 1] = '\0'; 4784 | 4785 | if (reading_from_mail) 4786 | { 4787 | fprintf(log_file, ">>> time: %s MAIL UPDATE <<<\n\n", time_str); 4788 | } 4789 | else if (networkupdate) 4790 | { 4791 | fprintf(log_file, ">>> time: %s NETWORKUPDATE UPDATE <<<\n\n", time_str); 4792 | } 4793 | else 4794 | { 4795 | fprintf(log_file, ">>> time: %s UPDATE <<<\n\n", time_str); 4796 | } 4797 | 4798 | free(time_str); 4799 | while ( fgets(buf, 1023, infile) != NULL ) 4800 | { 4801 | fprintf(log_file, "%s", buf); 4802 | } 4803 | free(updlogfile); 4804 | 4805 | fclose(infile); 4806 | fclose(log_file); 4807 | } 4808 | 4809 | 4810 | 4811 | /* Logs the object to the update log */ 4812 | void UP_log_networkupdate(const char * object_str, const char * host) 4813 | { 4814 | time_t now; 4815 | struct tm * tmstr; 4816 | time_t cur_time; 4817 | char * time_str; 4818 | char datestr[10]; 4819 | char * updlogfile; 4820 | FILE * log_file; 4821 | 4822 | /* We need to get the a date string to construct the updlog file name */ 4823 | time(&now); 4824 | tmstr = localtime(&now); 4825 | strftime(datestr, 10, "%Y%m%d", tmstr); 4826 | 4827 | /* now that we have the date string, we can construct updlog file name */ 4828 | updlogfile = (char *)malloc(strlen(updlog) + strlen(datestr) + 2); 4829 | snprintf(updlogfile, strlen(updlog) + strlen(datestr) + 2, 4830 | "%s.%s", updlog, datestr); 4831 | 4832 | if (( log_file = fopen(updlogfile, "a")) == NULL) 4833 | { 4834 | fprintf(stderr, "UP_add_to_upd_log: Can't open upd log file, %s\n", updlogfile); 4835 | free(updlogfile); 4836 | return; 4837 | } 4838 | free(updlogfile); 4839 | 4840 | /* get time */ 4841 | cur_time = time(NULL); 4842 | time_str = strdup(ctime(&cur_time)); 4843 | /* cut the '\n' at the end */ 4844 | time_str[strlen(time_str) - 1] = '\0'; 4845 | 4846 | fprintf(log_file, ">>> time: %s NETWORKUPDATE UPDATE (%s) <<<\n\n", time_str, host); 4847 | 4848 | free(time_str); 4849 | 4850 | fprintf(log_file, "%s\n", object_str); 4851 | 4852 | fclose(log_file); 4853 | } 4854 | 4855 | 4856 | 4857 | 4858 | /* Performs a preliminary check on a string: Tries to guess if the arg is an object or not. 4859 | The criteria is: If we have a colon (":") in the first line of the string, then it is 4860 | probably an object */ 4861 | int UP_is_object(const char * arg) 4862 | { 4863 | if (arg == NULL) 4864 | { 4865 | return 0; /* not an object */ 4866 | } 4867 | 4868 | if (index(arg ,'\n')) 4869 | { /* does it consist of multiple lines? */ 4870 | if (index(arg ,':') != NULL && (index(arg ,':') < index(arg ,'\n'))) 4871 | { 4872 | return 1; 4873 | } 4874 | else 4875 | { /* it doesn't have any ":" or, first ":" is not in the first line */ 4876 | return 0; 4877 | } 4878 | } 4879 | else 4880 | { /* it has a single line, possibly not an object */ 4881 | return 0; 4882 | } 4883 | } 4884 | 4885 | 4886 | int UP_remove_override_attr( rpsl_object_t *object ) 4887 | { 4888 | rpsl_error_t return_error; 4889 | rpsl_attr_t *removed_attr; 4890 | 4891 | return_error.code = (gint)NULL; 4892 | removed_attr = rpsl_object_remove_attr_name(object,"override",&return_error); 4893 | if ( (removed_attr == NULL) && return_error.level >= RPSL_ERRLVL_ERROR ) 4894 | { 4895 | /* error returned */ 4896 | /* could be that there was no override attribute in this object */ 4897 | if ( return_error.code == RPSL_ERR_NOSUCHATTR ) 4898 | return 1; /* This is OK, object has no override attribute */ 4899 | else 4900 | /* there was an override attr in this object and it has not been removed */ 4901 | return 0; 4902 | } 4903 | else 4904 | /* no errors, override attribute has been removed */ 4905 | return 1; 4906 | } 4907 | 4908 | 4909 | /****************************************************************************************************/ 4910 | 4911 | /******************* Redundant Functions ***********************************************************/ 4912 | 4913 | 4914 | 4915 | /* strips lines beginning with "override:" off */ 4916 | char * delete_override(char * arg){ 4917 | 4918 | char ** temp = NULL; 4919 | char * string = NULL; 4920 | int i; 4921 | 4922 | if(arg == NULL){ 4923 | return NULL; 4924 | } 4925 | 4926 | /* split the string into lines */ 4927 | temp = g_strsplit (arg, "\n", 0); 4928 | 4929 | for(i=0; temp[i] != NULL; i++){ 4930 | /* if the line begins with "override:", then do not copy it */ 4931 | if(strstr(temp[i], "override:") != temp[i]){ 4932 | if(string == NULL){ 4933 | string = strdup(temp[i]); 4934 | }else{ 4935 | string = (char *)realloc(string, strlen(string) + strlen(temp[i]) + 2); 4936 | string = strcat(string, "\n"); 4937 | string = strcat(string, temp[i]); 4938 | } 4939 | } 4940 | } 4941 | g_strfreev(temp); 4942 | return string; 4943 | } 4944 | 4945 | 4946 | /* takes a pre-parsed object, and returns its type */ 4947 | /* char * get_class_type(Object *arg){ 4948 | 4949 | char * be_returned = NULL; 4950 | if(arg == NULL) return NULL; 4951 | be_returned = strdup(arg->type->getName()); 4952 | return g_strstrip(be_returned); 4953 | } 4954 | */ 4955 | 4956 | 4957 | 4958 | 4959 | 4960 | 4961 | 4962 | /*************** still used in nt module **************/ 4963 | /* strips lines beginning with "delete:" off */ 4964 | char * delete_delete_attrib(char * arg){ 4965 | 4966 | char ** temp = NULL; 4967 | char * string = NULL; 4968 | int i; 4969 | 4970 | if(arg == NULL){ 4971 | return NULL; 4972 | } 4973 | 4974 | /* split the string into lines */ 4975 | temp = g_strsplit (arg, "\n", 0); 4976 | 4977 | for(i=0; temp[i] != NULL; i++){ 4978 | /* if the line begins with "delete:", then do not copy it */ 4979 | if(strstr(temp[i], "delete:") != temp[i]){ 4980 | if(string == NULL){ 4981 | string = strdup(temp[i]); 4982 | }else{ 4983 | string = (char *)realloc(string, strlen(string) + strlen(temp[i]) + 2); 4984 | string = strcat(string, "\n"); 4985 | string = strcat(string, temp[i]); 4986 | } 4987 | } 4988 | } 4989 | g_strfreev(temp); 4990 | return string; 4991 | }