components/visual-panels/core/src/cmd/rad/mod/panels/mod_panels.c
branchs11-update
changeset 2805 4888f6212f94
parent 901 19b502ccabc8
equal deleted inserted replaced
2804:7546c836fd87 2805:4888f6212f94
    18  *
    18  *
    19  * CDDL HEADER END
    19  * CDDL HEADER END
    20  */
    20  */
    21 
    21 
    22 /*
    22 /*
    23  * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
    23  * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
    24  */
    24  */
    25 
    25 
    26 #include <assert.h>
    26 #include <assert.h>
    27 #include <dirent.h>
    27 #include <dirent.h>
    28 #include <errno.h>
    28 #include <errno.h>
    32 #include <openssl/evp.h>
    32 #include <openssl/evp.h>
    33 #include <openssl/md5.h>
    33 #include <openssl/md5.h>
    34 #include <string.h>
    34 #include <string.h>
    35 #include <sys/stat.h>
    35 #include <sys/stat.h>
    36 #include <unistd.h>
    36 #include <unistd.h>
    37 #include "api_panels.h"
    37 #include "api_panel.h"
    38 
    38 
    39 #define	PANELDESCDIR	"/usr/share/vpanels/conf"
    39 #define	PANELDESCDIR	"/usr/share/vpanels/conf"
    40 
    40 
    41 #define	HASH_BSIZE	65536
    41 #define	HASH_BSIZE	65536
    42 
    42 
    61 /*
    61 /*
    62  * Static data
    62  * Static data
    63  */
    63  */
    64 
    64 
    65 static xmlDtd *dtd;
    65 static xmlDtd *dtd;
    66 static rad_modinfo_t modinfo = { "panels", "Visual Panels module" };
       
    67 
    66 
    68 /*
    67 /*
    69  * Static functions
    68  * Static functions
    70  */
    69  */
    71 
    70 
   180 			nullcnt++;
   179 			nullcnt++;
   181 		}
   180 		}
   182 	}
   181 	}
   183 	if (nullcnt != 3 || token[tokenlen - 1] != '\0') {
   182 	if (nullcnt != 3 || token[tokenlen - 1] != '\0') {
   184 		/* Bad token */
   183 		/* Bad token */
   185 		return (ce_object);
   184 		return (CE_OBJECT);
   186 	}
   185 	}
   187 
   186 
   188 	char *locale = token;
   187 	char *locale = token;
   189 	char *pname = locale + strlen(locale) + 1;
   188 	char *pname = locale + strlen(locale) + 1;
   190 	char *file = pname + strlen(pname) + 1;
   189 	char *file = pname + strlen(pname) + 1;
   191 
   190 
   192 	adr_data_t *panel = read_panel(locale, pname);
   191 	adr_data_t *panel = read_panel(locale, pname);
   193 	if (panel == NULL) {
   192 	if (panel == NULL) {
   194 		/* Bad panel */
   193 		/* Bad panel */
   195 		return (ce_object);
   194 		return (CE_OBJECT);
   196 	}
   195 	}
   197 
   196 
   198 	adr_data_t *resources = adr_struct_get(panel, "resourceDescriptors");
   197 	adr_data_t *resources = adr_struct_get(panel, "resourceDescriptors");
   199 	static const char * const path[] = { "file", NULL };
   198 	static const char * const path[] = { "file", NULL };
   200 	int index = adr_array_search(resources, file, path);
   199 	int index = adr_array_search(resources, file, path);
   201 	adr_data_free(panel);
   200 	adr_data_free(panel);
   202 	if (index == -1) {
   201 	if (index == -1) {
   203 		/* Bad file */
   202 		/* Bad file */
   204 		return (ce_object);
   203 		return (CE_OBJECT);
   205 	}
   204 	}
   206 
   205 
   207 	*f = strdup(file);
   206 	*f = strdup(file);
   208 	if (*f == NULL) {
   207 	if (*f == NULL) {
   209 		return (ce_nomem);
   208 		return (CE_NOMEM);
   210 	}
   209 	}
   211 
   210 
   212 	return (ce_ok);
   211 	return (CE_OK);
   213 }
   212 }
   214 
   213 
   215 static adr_data_t *
   214 static adr_data_t *
   216 create_resource(rad_locale_t *rlocale, const char *pname, char *file)
   215 create_resource(rad_locale_t *rlocale, const char *pname, char *file)
   217 {
   216 {
   406 /*
   405 /*
   407  * Extern functions
   406  * Extern functions
   408  */
   407  */
   409 
   408 
   410 int
   409 int
   411 _rad_init(void *handle)
   410 _rad_init(void)
   412 {
   411 {
   413 	if (rad_module_register(handle, RAD_MODVERSION, &modinfo) == -1)
       
   414 		return (-1);
       
   415 
       
   416 	dtd = xmlParseDTD(NULL,
   412 	dtd = xmlParseDTD(NULL,
   417 	    (xmlChar *)"/usr/share/lib/xml/dtd/vpanel.dtd.1");
   413 	    (xmlChar *)"/usr/share/lib/xml/dtd/vpanel.dtd.1");
   418 
   414 
   419 	adr_name_t *name = adr_name_fromstr(
   415 	adr_name_t *aname = adr_name_vcreate(MOD_DOMAIN, 1, "type", "Panel");
   420 	    "com.oracle.solaris.vp.panel.common.api.panel:type=Panel");
   416 	conerr_t cerr =  rad_cont_insert_singleton(rad_container, aname,
   421 	(void) cont_insert_singleton(rad_container, name, &interface_Panel_svr);
   417 	    &modinfo, &interface_Panel_svr);
       
   418 	adr_name_rele(aname);
       
   419 	if (cerr != CE_OK) {
       
   420 		rad_log(RL_ERROR, "(mod_panels) failed to insert Panel");
       
   421 		return (-1);
       
   422 	}
   422 
   423 
   423 	return (0);
   424 	return (0);
       
   425 }
       
   426 
       
   427 /*
       
   428  * _rad_fini is called by the RAD daemon when the module is unloaded. Any
       
   429  * module finalisation is completed here.
       
   430  */
       
   431 /*ARGSUSED*/
       
   432 void
       
   433 _rad_fini(void *unused)
       
   434 {
   424 }
   435 }
   425 
   436 
   426 /* ARGSUSED */
   437 /* ARGSUSED */
   427 conerr_t
   438 conerr_t
   428 interface_Panel_invoke_getPanel(rad_instance_t *inst, adr_method_t *meth,
   439 interface_Panel_invoke_getPanel(rad_instance_t *inst, adr_method_t *meth,
   436 	if (panel == NULL) {
   447 	if (panel == NULL) {
   437 		/*
   448 		/*
   438 		 * Could be a memory or system error, but more likely an invalid
   449 		 * Could be a memory or system error, but more likely an invalid
   439 		 * name was specified.
   450 		 * name was specified.
   440 		 */
   451 		 */
   441 		return (ce_object);
   452 		return (CE_OBJECT);
   442 	}
   453 	}
   443 	*ret = panel;
   454 	*ret = panel;
   444 
   455 
   445 	return (ce_ok);
   456 	return (CE_OK);
   446 }
   457 }
   447 
   458 
   448 /* ARGSUSED */
   459 /* ARGSUSED */
   449 conerr_t
   460 conerr_t
   450 interface_Panel_read_panelNames(rad_instance_t *inst, adr_attribute_t *attr,
   461 interface_Panel_read_panelNames(rad_instance_t *inst, adr_attribute_t *attr,
   451     adr_data_t **data, adr_data_t **error)
   462     adr_data_t **data, adr_data_t **error)
   452 {
   463 {
   453 	adr_data_t *array = adr_data_new_array(&adr_t_array_string, 0);
   464 	adr_data_t *array = adr_data_new_array(&adr_t_array_string, 0);
   454 	if (array == NULL) {
   465 	if (array == NULL) {
   455 		return (ce_nomem);
   466 		return (CE_NOMEM);
   456 	}
   467 	}
   457 
   468 
   458 	DIR *d;
   469 	DIR *d;
   459 	if ((d = opendir(PANELDESCDIR)) == NULL) {
   470 	if ((d = opendir(PANELDESCDIR)) == NULL) {
   460 		if (errno == ENOENT) {
   471 		if (errno == ENOENT) {
   461 			return (ce_ok);
   472 			return (CE_OK);
   462 		}
   473 		}
   463 		return (ce_system);
   474 		return (CE_SYSTEM);
   464 	}
   475 	}
   465 
   476 
   466 	struct dirent *ent;
   477 	struct dirent *ent;
   467 	while ((ent = readdir(d)) != NULL) {
   478 	while ((ent = readdir(d)) != NULL) {
   468 		char *ext = ".xml";
   479 		char *ext = ".xml";
   475 	}
   486 	}
   476 
   487 
   477 	(void) closedir(d);
   488 	(void) closedir(d);
   478 	*data = adr_data_purify(array);
   489 	*data = adr_data_purify(array);
   479 
   490 
   480 	return (*data == NULL ? ce_nomem : ce_ok);
   491 	return (*data == NULL ? CE_NOMEM : CE_OK);
   481 }
   492 }
   482 
   493 
   483 /* ARGSUSED */
   494 /* ARGSUSED */
   484 conerr_t
   495 conerr_t
   485 interface_Panel_invoke_getResource(rad_instance_t *inst, adr_method_t *meth,
   496 interface_Panel_invoke_getResource(rad_instance_t *inst, adr_method_t *meth,
   486     adr_data_t **ret, adr_data_t **args, int count, adr_data_t **error)
   497     adr_data_t **ret, adr_data_t **args, int count, adr_data_t **error)
   487 {
   498 {
   488 	char *file;
   499 	char *file;
   489 	conerr_t result = token_to_file(args[0], &file);
   500 	conerr_t result = token_to_file(args[0], &file);
   490 	if (result != ce_ok) {
   501 	if (result != CE_OK) {
   491 		return (result);
   502 		return (result);
   492 	}
   503 	}
   493 
   504 
   494 	struct stat st;
   505 	struct stat st;
   495 	if (stat(file, &st) != 0) {
   506 	if (stat(file, &st) != 0) {
   496 		free(file);
   507 		free(file);
   497 		return (ce_object);
   508 		return (CE_OBJECT);
   498 	}
   509 	}
   499 
   510 
   500 	char *buffer = malloc(st.st_size);
   511 	char *buffer = malloc(st.st_size);
   501 	if (buffer == NULL) {
   512 	if (buffer == NULL) {
   502 		free(file);
   513 		free(file);
   503 		return (ce_nomem);
   514 		return (CE_NOMEM);
   504 	}
   515 	}
   505 
   516 
   506 	int fd = open(file, O_RDONLY);
   517 	int fd = open(file, O_RDONLY);
   507 	free(file);
   518 	free(file);
   508 	if (fd == -1) {
   519 	if (fd == -1) {
   509 		free(buffer);
   520 		free(buffer);
   510 		return (ce_priv);
   521 		return (CE_PRIV);
   511 	}
   522 	}
   512 
   523 
   513 	if (read(fd, buffer, st.st_size) != st.st_size) {
   524 	if (read(fd, buffer, st.st_size) != st.st_size) {
   514 		(void) close(fd);
   525 		(void) close(fd);
   515 		free(buffer);
   526 		free(buffer);
   516 		return (ce_system);
   527 		return (CE_SYSTEM);
   517 	}
   528 	}
   518 
   529 
   519 	(void) close(fd);
   530 	(void) close(fd);
   520 
   531 
   521 	*ret = adr_data_new_opaque(buffer, st.st_size, LT_FREE);
   532 	*ret = adr_data_new_opaque(buffer, st.st_size, LT_FREE);
   522 	return (*ret == NULL ? ce_nomem : ce_ok);
   533 	return (*ret == NULL ? CE_NOMEM : CE_OK);
   523 }
   534 }