]> rtime.felk.cvut.cz Git - frescor/forb.git/blob - src/forb.c
Added application exception
[frescor/forb.git] / src / forb.c
1 /**************************************************************************/
2 /* ---------------------------------------------------------------------- */
3 /* Copyright (C) 2006 - 2008 FRESCOR consortium partners:                 */
4 /*                                                                        */
5 /*   Universidad de Cantabria,              SPAIN                         */
6 /*   University of York,                    UK                            */
7 /*   Scuola Superiore Sant'Anna,            ITALY                         */
8 /*   Kaiserslautern University,             GERMANY                       */
9 /*   Univ. Politécnica  Valencia,           SPAIN                        */
10 /*   Czech Technical University in Prague,  CZECH REPUBLIC                */
11 /*   ENEA                                   SWEDEN                        */
12 /*   Thales Communication S.A.              FRANCE                        */
13 /*   Visual Tools S.A.                      SPAIN                         */
14 /*   Rapita Systems Ltd                     UK                            */
15 /*   Evidence                               ITALY                         */
16 /*                                                                        */
17 /*   See http://www.frescor.org for a link to partners' websites          */
18 /*                                                                        */
19 /*          FRESCOR project (FP6/2005/IST/5-034026) is funded             */
20 /*       in part by the European Union Sixth Framework Programme          */
21 /*       The European Union is not liable of any use that may be          */
22 /*       made of this code.                                               */
23 /*                                                                        */
24 /*                                                                        */
25 /*  This file is part of FORB (Frescor Object Request Broker)             */
26 /*                                                                        */
27 /* FORB is free software; you can redistribute it and/or modify it        */
28 /* under terms of the GNU General Public License as published by the      */
29 /* Free Software Foundation; either version 2, or (at your option) any    */
30 /* later version.  FORB is distributed in the hope that it will be        */
31 /* useful, but WITHOUT ANY WARRANTY; without even the implied warranty    */
32 /* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU    */
33 /* General Public License for more details. You should have received a    */
34 /* copy of the GNU General Public License along with FORB; see file       */
35 /* COPYING. If not, write to the Free Software Foundation, 675 Mass Ave,  */
36 /* Cambridge, MA 02139, USA.                                              */
37 /*                                                                        */
38 /* As a special exception, including FORB header files in a file,         */
39 /* instantiating FORB generics or templates, or linking other files       */
40 /* with FORB objects to produce an executable application, does not       */
41 /* by itself cause the resulting executable application to be covered     */
42 /* by the GNU General Public License. This exception does not             */
43 /* however invalidate any other reasons why the executable file might be  */
44 /* covered by the GNU Public License.                                     */
45 /**************************************************************************/
46
47 /**
48  * @file   forb.c
49  * @author Michal Sojka <sojkam1@fel.cvut.cz>
50  * @date   Sun Oct 12 16:57:01 2008
51  * 
52  * @brief  Implementation of basic FORB's functions.
53  * 
54  * 
55  */
56
57 #define _BSD_SOURCE             /* Because of on_exit()  */
58 #include "proto.h"
59 #include "regref.h"
60 #include "regref.h"
61 #include <fcntl.h>
62 #include <forb/config.h>
63 #include <forb/forb-internal.h>
64 #include <forb.h>
65 #include "forb-idl.h"
66 #include <forb/iop.h>
67 #include <forb/object.h>
68 #include <forb/uuid.h>
69 #include <stdio.h>
70 #include <stdlib.h>
71 #include <string.h>
72 #include <sys/stat.h>
73 #include <sys/types.h>
74 #include <ul_gavlcust.h>
75 #include <ul_log.h>
76 #include <ul_logreg.h>
77 #include <unistd.h>
78 #ifdef CONFIG_FORB_PROTO_UNIX
79 #include <forb/proto_unix.h>
80 #endif
81
82 #ifdef DEBUG
83 #define UL_LOGL_DEF UL_LOGL_DEB
84 #else
85 #define UL_LOGL_DEF UL_LOGL_ERR
86 #endif
87 #include "log_domains.inc"
88
89 extern UL_LOG_CUST(ulogd_forb);
90
91
92 static void
93 destroy_forb_on_exit(int exitcode, void *arg)
94 {
95         forb_orb orb = arg;
96         forb_destroy(orb);
97 }
98
99 static void
100 forb_is_alive(forb_orb _obj, CORBA_Environment *ev)
101 {
102         ul_logdeb("%s called\n", __FUNCTION__);
103 }
104
105 static struct forb_forb_orb_impl forb_implementation = {
106         .is_alive = forb_is_alive,
107 };
108
109 /**
110  * Prepares #FORB_TMP_DIR directory for use by forb
111  *
112  * @return Zero on succes, -1 on error and errno is set appropriately.
113  */
114 int
115 forb_init_tmp_dir(void)
116 {
117         struct stat st;
118         int ret;
119
120         ret = stat(FORB_TMP_DIR, &st);
121
122         if (ret == 0 && !S_ISDIR(st.st_mode)) {
123                 ret = unlink(FORB_TMP_DIR);
124                 if (ret) return -1;
125         } else if (ret == 0) {
126                 return 0;
127         }
128         return mkdir(FORB_TMP_DIR, 0777);
129 }
130
131 /** 
132  * Thread for execution of remote requests for a FORB object.
133  * 
134  * @param arg 
135  * 
136  * @return 
137  */
138 static void *
139 forb_execution_thread(void *arg)
140 {
141         forb_orb orb = arg;
142
143         forb_execute_object(orb);
144         return NULL;
145 }
146
147 forb_orb
148 forb_init(int *argc, char **argv[], const char *orb_id)
149 {
150         forb_orb orb;
151         forb_t *forb;
152         int ret;
153
154         forb = forb_malloc(sizeof(*forb));
155         if (!forb) goto err;
156         memset(forb, 0, sizeof(*forb));
157
158         /* Initialize ULUT logging facility */
159         ul_logreg_domains_static(ul_log_domains_array,
160                                  sizeof(ul_log_domains_array)/sizeof(ul_log_domains_array[0]));
161         
162         forb_server_id_init(&forb->server_id);
163         forb_server_id_to_string(forb->server_id_str, &forb->server_id,
164                                  sizeof(forb->server_id_str));
165         ul_logdeb("Initializing forb %s\n", forb->server_id_str);
166
167         if (fosa_mutex_init(&forb->request_id_mutex, 0) != 0) goto err2;
168         if (fosa_mutex_init(&forb->port_mutex, 0) != 0) goto err2;
169         forb_port_init_head(forb);
170         
171         if (fosa_mutex_init(&forb->request_mutex, 0) != 0) goto err2;
172         forb_request_nolock_init_root_field(forb);
173         
174         if (fosa_mutex_init(&forb->peer_mutex, 0) != 0) goto err2;
175         forb_peer_nolock_init_root_field(forb);
176
177         if (fosa_mutex_init(&forb->objkey_mutex, 0) != 0) goto err2;
178         forb_objects_nolock_init_root_field(forb);
179
180         if (fosa_mutex_init(&forb->regref_mutex, 0) != 0) goto err2;
181         forb_regref_nolock_init_root_field(forb);
182
183         ret = forb_init_tmp_dir();
184         if (ret != 0) {
185                 ul_logerr("Cannot prepare " FORB_TMP_DIR "\n");
186                 return NULL;
187         }
188
189         orb = forb_forb_orb_new(NULL, &forb_implementation, forb);
190         if (!orb) goto err2;
191         /* Server ID must be assigned manualy */
192         orb->server = forb->server_id;
193
194         /* Insert our object reference to objects tree, so that we
195          * can accept remote request to our new ORB. */
196         forb_objects_nolock_insert(forb, orb);
197
198         ret = fosa_thread_create(&forb->execution_thread, NULL,
199                                  forb_execution_thread, orb);
200         if (ret != 0)
201                 goto err2;
202         
203         on_exit(destroy_forb_on_exit, orb);
204
205 #ifdef CONFIG_FORB_PROTO_UNIX
206         {
207                 forb_port_t *port = forb_malloc(sizeof(*port));
208                 if (port) {
209                         forb_unix_port_init(port, &forb->server_id);
210                         forb_register_port(forb, port);
211                 }
212         }
213 #endif
214         return orb;
215
216 err2:   forb_free(forb);
217 err:    return NULL;
218 }
219
220 /* FIXME: forb_destroy is now called automatically on exit. Therefore
221  * forb_destroy() should be either static or should deregister on_exit
222  * handler (how???).  */
223 void forb_destroy(forb_orb orb)
224 {
225         forb_t *forb = forb_object_to_forb(orb);
226         forb_port_t *port;
227         forb_regref_t *regref;
228
229         pthread_cancel(forb->execution_thread.pthread_id);
230         pthread_join(forb->execution_thread.pthread_id, NULL);
231         
232         /* Unregister all registered references */
233         while ((regref = forb_regref_first(forb))) {
234                 forb_unregister_reference(orb, regref->name);
235         }
236         
237         ul_list_for_each_cut(forb_port, forb, port) {
238                 forb_destroy_port(port);
239         }
240         forb_object_release(orb);
241         forb_free(forb);
242 }
243
244 /* void */
245 /* forb_register_interface(const struct forb_interface *interface) */
246 /* { */
247 /*      gavl_insert(&type_registry, &interface->node); */
248 /* } */
249
250 /** 
251  * Initializes server ID variable.
252  * 
253  * @param server_id Serer ID to initialize.
254  */
255 void
256 forb_server_id_init(forb_server_id *server_id)
257 {
258         forb_uuid_generate((forb_uuid_t*)server_id->uuid);
259 }
260
261 /** 
262  * Checks whether the @a object is stale. Stale object is an object
263  * reference whose server cannot be contacted to handle requests.
264  * 
265  * @param object Object reference to check.
266  * 
267  * @return True if the object is stale, false otherwise.
268  */
269 bool forb_object_is_stale(forb_object object)
270 {
271         forb_orb remote_orb;
272         struct forb_env env;
273         bool stale = true;
274         
275         remote_orb = forb_get_orb_of(object);
276         if (!remote_orb) {      /* This shohuld never happen */
277                 goto err;
278         }
279         /* TODO: Check not only the ORB, but also whether the object
280          * is still registered with the remote orb. */
281         forb_orb_is_alive(remote_orb, &env);
282         if (env.major == FORB_EX_COMM_FAILURE) {
283                 /* Orb is not alive */
284                 stale = true;
285         } else {
286                 if (forb_exception_occured(&env)) {
287                         ul_logerr("%s: unexpected exception: %s\n", __FUNCTION__, forb_strerror(&env));
288                 }
289                 stale = false;  
290         }
291
292         forb_object_release(remote_orb);
293 err:
294         return stale;
295 }
296
297 /** 
298  * 
299  * 
300  * @param fd 
301  * @param objref 
302  * 
303  * @return Zero on success, -1 on error.
304  */
305 static int
306 rewrite_regref(int fd, const char *objref)
307 {
308         int ret;
309         int len = strlen(objref);
310         lseek(fd, 0, SEEK_SET);
311         ftruncate(fd, 0);
312                 
313         while (len > 0) {
314                 ret = write(fd, objref, len);
315                 if (ret < 0) goto out;
316                 len -= ret;
317                 objref += ret;
318         }
319         ret = 0;        /* Success */
320 out:
321         return ret;
322 }
323
324 /** 
325  * 
326  * 
327  * @param orb 
328  * @param fn File name
329  * @param objref string form of the object reference
330  * 
331  * @return -1 on error, 0 if reference was replaced and 1 in the
332  * reference is valid.
333  */
334 static int
335 replace_regref_if_stale(forb_orb orb, const char *fn, const char *objref)
336 {
337         int fd, ret = 0; 
338         char str[100];
339         forb_object object;
340         
341         fd = open(fn, O_RDWR);
342         if (fd < 0) {
343                 ret = -1;
344                 goto out;
345         }
346         ret = lockf(fd, F_LOCK, 0);
347         if (ret < 0) goto close_err;
348         ret = read(fd, str, sizeof(str)-1);
349         if (ret < 0) goto unlock_err;
350         /* TODO: Check that we have read the whole file */
351         
352         str[ret] = '\0';
353         object = forb_string_to_object(orb, str);
354         if (!object) {
355                 /* reference is unreadable, so we can replace it */
356                 ret = rewrite_regref(fd, objref);
357                 /* We are done for now */
358                 goto unlock_err;
359         }
360         if (forb_object_is_stale(object)) {
361                 /* Orb is not alive */
362                 ret = rewrite_regref(fd, objref);
363         } else {
364                 /* Reference's FORB is alive :-( */
365                 ret = 1;        
366         }
367
368         forb_object_release(object);
369 unlock_err:     
370         lockf(fd, F_ULOCK, 0);
371 close_err:
372         close(fd);
373 out:
374         return ret;
375 }
376
377
378 /** 
379  * Registers a given object reference so that other FORBs on the same
380  * node can find it by using forb_resolve_reference().
381  * 
382  * @param object Object reference to register.
383  * @param name Name under which to register the reference.
384  *
385  * @return Zero on success, -1 on error.
386  */
387 int
388 forb_register_reference(forb_object object, const char *name)
389 {
390         forb_regref_t *regref;
391         forb_regref_name_t regname;
392         forb_t *forb = forb_object_to_forb(object);
393         char fn[100], fntmp[100];
394         char *objref;
395         FILE *f;
396         int ret;
397
398         strncpy(regname, name, FORB_REGREF_NAME_LEN-1);
399         regname[FORB_REGREF_NAME_LEN-1]='\0';
400
401         regref = forb_regref_new(object, regname);
402         if (!regref) goto err;
403
404         forb_regref_insert(forb, regref);
405
406         snprintf(fn,    sizeof(fn),    FORB_TMP_DIR "/%s",    regname);
407         snprintf(fntmp, sizeof(fntmp), FORB_TMP_DIR "/%s.%s", regname,
408                  forb->server_id_str);
409
410         f = fopen(fntmp, "w");
411         if (!f) goto unalloc_err;
412         
413         objref = forb_object_to_string(object);
414         if (!objref) goto unlink_err;
415
416         ret = fprintf(f, "%s", objref);
417         if (ret < 0) goto free_objref_err;
418
419         ret = fclose(f);
420         if (ret == EOF) goto free_objref_err;
421
422         /* Make the atomic registration in filesystem */
423         ret = link(fntmp, fn);
424         
425         if (ret < 0 && errno == EEXIST) {
426                 /* The reference exists. Try whether it is still
427                  * active. */
428                 if (replace_regref_if_stale(object->orb, fn, objref) != 0) {
429                         goto free_objref_err;
430                 }
431                 ul_logdeb("Stale registration replaced\n");
432         } else if (ret < 0) {
433                 goto free_objref_err;
434         }
435
436         forb_free(objref);
437
438         /* Unlink the temporary filename */
439         unlink(fntmp);
440         
441         return 0;
442 free_objref_err:
443         ret = errno;
444         forb_free(objref);
445         errno = ret;
446 unlink_err:
447         ret = errno;
448         unlink(fntmp);
449         errno = ret;
450 unalloc_err:
451         ret = errno;
452         forb_regref_delete(forb, regref);
453         forb_regref_release(regref);
454         errno = ret;
455 err:
456         return -1;
457 }
458
459 /** 
460  * Unregister reference previously registered by
461  * forb_register_reference().
462  * 
463  * @param orb forb::orb reference
464  * @param name Name to unregister.
465  * 
466  * @return Zero on success, -1 on error.
467  */
468 int
469 forb_unregister_reference(forb_orb orb, const char *name)
470 {
471         forb_regref_t *regref;
472         forb_regref_name_t regname;
473         forb_t *forb = forb_object_to_forb(orb);
474         char fn[100];
475
476         strncpy(regname, name, FORB_REGREF_NAME_LEN-1);
477         regname[FORB_REGREF_NAME_LEN-1]='\0';
478
479         regref = forb_regref_find(forb, &regname);
480         if (!regref) goto err;
481
482         forb_regref_delete(forb, regref);
483         forb_regref_release(regref);
484
485         snprintf(fn,    sizeof(fn),    FORB_TMP_DIR "/%s",    regname);
486         return unlink(fn);
487
488         return 0;
489 err:
490         return -1;
491 }
492
493 /** 
494  * Returns a named reference previously registered by
495  * forb_register_reference(). This function can be called event if the
496  * reference was registered in a diferent process (but on the same
497  * node).
498  * 
499  * @param orb Local orb object reference
500  * @param name Name under which the reference was registered.
501  * 
502  * @return Object reference on NULL in case of error.
503  */
504 forb_object
505 forb_resolve_reference(const forb_orb orb, const char *name)
506 {
507         forb_regref_name_t regname;
508         char fn[100];
509         char str[100];
510         int fd, ret;
511         forb_object object;
512
513         strncpy(regname, name, FORB_REGREF_NAME_LEN-1);
514         regname[FORB_REGREF_NAME_LEN-1]='\0';
515
516         snprintf(fn,    sizeof(fn),    FORB_TMP_DIR "/%s",    regname);
517
518         fd = open(fn, 0);
519         if (fd < 0) {
520                 return NULL;
521         }
522         ret = read(fd, str, sizeof(str)-1);
523         /* TODO: Check that we have read the whole file */
524         str[ret] = '\0';
525         object = forb_string_to_object(orb, str);
526         close(fd);
527
528         if (forb_object_is_stale(object)) {
529                 forb_object_release(object);
530                 object = NULL;
531         }
532         
533         return object;
534 }
535
536 /** 
537  * Returns object reference of forb::orb object associated with a
538  * given object.
539  * 
540  * @param obj 
541  * 
542  * @return 
543  */
544 forb_orb
545 forb_get_orb_of(const forb_object obj)
546 {
547         forb_orb orb;
548
549         if (forb_server_id_cmp(&obj->server, &obj->orb->server) == 0) {
550                 orb = forb_object_duplicate(orb);
551         } else {
552                 orb = forb_object_new(obj->orb, &obj->server, 0);
553         }
554         return orb;
555 }
556
557 /** 
558  * Returns server ID of an object reference.
559  * 
560  * @param obj 
561  * @param dest 
562  */
563 void
564 forb_get_server_id(const forb_object obj, forb_server_id *dest)
565 {
566         if (obj) {
567                 *dest = obj->server;
568         }
569 }
570
571
572 /** 
573  * Return instance data registered when the object was created by
574  * forb_XXX_new().
575  * 
576  * @param obj Object reference
577  * 
578  * @return Pointer to the registered data.
579  */
580 void *
581 forb_instance_data(const forb_object obj)
582 {
583         return forb_object_instance_data(obj);
584 }
585
586 /** 
587  * Returns error message correspondings FORB exception.
588  * 
589  * @param env Environemnt
590  * 
591  * @return Non-NULL pointer to a string.
592  */
593 const char *
594 forb_strerror(CORBA_Environment *env)
595 {
596         if (!env) {
597                 return "Invalid environemnt";
598         }
599 #define ex(e) case FORB_EX_##e: return #e; break;
600         switch (env->major) {
601         ex(NONE);
602         ex(UNKNOWN);
603         ex(BAD_PARAM);
604         ex(NO_MEMORY);
605         ex(IMP_LIMIT);
606         ex(COMM_FAILURE);
607         ex(INV_OBJREF);
608         ex(NO_PERMISSION);
609         ex(INTERNAL);
610         ex(MARSHAL);
611         ex(INITIALIZE);
612         ex(NO_IMPLEMENT);
613         ex(BAD_OPERATION);
614         ex(NO_RESOURCES);
615         ex(NO_RESPONSE);
616         ex(TRANSIENT);
617         ex(FREE_MEM);
618         ex(INV_IDENT);
619         ex(INV_FLAG);
620         ex(DATA_CONVERSION);
621         ex(OBJECT_NOT_EXIST);
622         ex(TIMEOUT);
623         ex(APPLICATION);
624         }
625 #undef ex
626         return "Invalid error number";
627 }
628
629 /** 
630  * Return server id of the requesting application.
631  *
632  * This function should be only called from within interface
633  * implementation,
634  * 
635  * @param[in] obj Object being requested
636  * @param[out] req_source Server ID of the requesting application
637  */
638 void
639 forb_get_req_source(const forb_object obj, forb_server_id *req_source)
640 {
641         if (req_source) {
642                 if (obj && obj->exec_req) {
643                         *req_source = obj->exec_req->source;
644                 } else {
645                         memset(req_source, 0, sizeof(*req_source));
646                 }
647         }
648 }