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