android/boot-properties.c - platform/external/qemu - Git at Google

 /* Copyright (C) 2009 The Android Open Source Project
 **
 ** This software is licensed under the terms of the GNU General Public
 ** License version 2, as published by the Free Software Foundation, and
 ** may be copied, distributed, and modified under those terms.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 */

 #include "android/boot-properties.h"
 #include "android/utils/debug.h"
 #include "android/utils/system.h"
 #include "android/hw-qemud.h"
 #include "android/globals.h"

 #include "hw/hw.h"

 #define  D(...)  VERBOSE_PRINT(init,__VA_ARGS__)

 /* define T_ACTIVE to 1 to debug transport communications */
 #define  T_ACTIVE  0

 #if T_ACTIVE
 #define  T(...)  VERBOSE_PRINT(init,__VA_ARGS__)
 #else
 #define  T(...)   ((void)0)
 #endif

 /* this code supports the list of system properties that will
  * be set on boot in the emulated system.
  */

 typedef struct BootProperty {
     struct BootProperty*  next;
     char*                 property;
     int                   length;
 } BootProperty;

 static BootProperty*
 boot_property_alloc( const char*  name,  int  namelen,
                      const char*  value, int  valuelen )
 {
     int            length = namelen + 1 + valuelen;
     BootProperty*  prop = android_alloc( sizeof(*prop) + length + 1 );
     char*          p;

     prop->next     = NULL;
     prop->property = p = (char*)(prop + 1);
     prop->length   = length;

     memcpy( p, name, namelen );
     p += namelen;
     *p++ = '=';
     memcpy( p, value, valuelen );
     p += valuelen;
     *p = '\0';

     return prop;
 }

 static BootProperty*   _boot_properties = NULL;
 /* address to store pointer to next new list element */
 static BootProperty**  _boot_properties_tail = &_boot_properties;
 static int             _inited;

 /* Clears all existing boot properties
  */
 static void
 boot_property_clear_all()
 {
     /* free all elements of the linked list */
     BootProperty *p = _boot_properties;
     BootProperty *next = NULL;
     while (p) {
         next = p->next;
         AFREE(p);
         p = next;
     }

     /* reset list administration to initial state */
     _boot_properties = NULL;
     _boot_properties_tail = &_boot_properties;
 }

 /* Appends a new boot property to the end of the internal list.
  */
 int
 boot_property_add2( const char*  name, int  namelen,
                     const char*  value, int  valuelen )
 {
     BootProperty*  prop;

     /* check the lengths
      */
     if (namelen > PROPERTY_MAX_NAME)
         return -1;

     if (valuelen > PROPERTY_MAX_VALUE)
         return -2;

     /* check that there are not invalid characters in the
      * property name
      */
     const char*  reject = " =$*?'\"";
     int          nn;

     for (nn = 0; nn < namelen; nn++) {
         if (strchr(reject, name[nn]) != NULL)
             return -3;
     }

     /* init service if needed */
     if (!_inited) {
         boot_property_init_service();
         _inited = 1;
     }

     D("Adding boot property: '%.*s' = '%.*s'",
       namelen, name, valuelen, value);

     /* add to the end of the internal list */
     prop = boot_property_alloc(name, namelen, value, valuelen);

     *_boot_properties_tail = prop;
     _boot_properties_tail  = &prop->next;

     return 0;
 }

 /* Prints the warning string corresponding to the error code returned by
  * boot_propery_add2().
  */
 static void
 boot_property_raise_warning( int ret, const char*  name, int  namelen,
                              const char*  value, int  valuelen )
 {
     switch (ret) {
     case -1:
         dwarning("boot property name too long: '%.*s'",
                     namelen, name);
         break;
     case -2:
         dwarning("boot property value too long: '%.*s'",
                     valuelen, value);
         break;
     case -3:
         dwarning("boot property name contains invalid chars: %.*s",
                     namelen, name);
         break;
     }
 }

 int
 boot_property_add( const char*  name, const char*  value )
 {
     int  namelen = strlen(name);
     int  valuelen = strlen(value);

     return boot_property_add2(name, namelen, value, valuelen);
 }

 /* Saves a single BootProperty to file.
  */
 static int
 boot_property_save_property( QEMUFile  *f, BootProperty  *p )
 {
     /* split in key and value, so we can re-use boot_property_add (and its
      * sanity checks) when loading
      */

     char *split = strchr(p->property, '=');
     if (split == NULL) {
         D("%s: save failed: illegal key/value pair \"%s\" (missing '=')\n",
           __FUNCTION__, p->property);
         qemu_file_set_error(f);
         return -1;
     }

     *split = '\0';  /* p->property is now "<key>\0<value>\0" */

     uint32_t key_buf_len = (split - p->property) + 1; // +1: '\0' terminator
     qemu_put_be32(f, key_buf_len);
     qemu_put_buffer(f, (uint8_t*) p->property, key_buf_len);

     uint32_t value_buf_len = p->length - key_buf_len + 1; // +1: '\0' terminator
     qemu_put_be32(f, value_buf_len);
     qemu_put_buffer(f, (uint8_t*) split + 1, value_buf_len);

     *split = '=';  /* restore property to "<key>=<value>\0" */

     return 0;
 }

 /* Loads a single boot property from a snapshot file
  */
 static int
 boot_property_load_property( QEMUFile  *f )
 {
     int ret;

     /* load key */
     uint32_t key_buf_len = qemu_get_be32(f);
     char* key = android_alloc(key_buf_len);
     if ((ret = qemu_get_buffer(f, (uint8_t*)key, key_buf_len) != key_buf_len)) {
         D("%s: key load failed: expected %d bytes, got %d\n",
           __FUNCTION__, key_buf_len, ret);
         goto fail_key;
     }

     /* load value */
     uint32_t value_buf_len = qemu_get_be32(f);
     char* value = android_alloc(value_buf_len);
     if ((ret = qemu_get_buffer(f, (uint8_t*)value, value_buf_len) != value_buf_len)) {
         D("%s: value load failed: expected %d bytes, got %d\n",
           __FUNCTION__, value_buf_len, ret);
         goto fail_value;
     }

     /* add the property */
     ret = boot_property_add2(key, key_buf_len - 1, value, value_buf_len - 1);
     if (ret < 0) {
         D("%s: load failed: cannot add boot property (details follow)\n",
           __FUNCTION__);
         boot_property_raise_warning(ret, key, key_buf_len - 1, value, value_buf_len - 1);
         goto fail_value;
     }

     return 0;

     /* in case of errors, clean up before return */
     fail_value:
         AFREE(value);
     fail_key:
         AFREE(key);
         return -EIO;
 }

 /* Saves the number of available boot properties to file
  */
 static void
 boot_property_save_count( QEMUFile*  f, BootProperty*  p )
 {
     uint32_t property_count = 0;
     for (; p; p = p->next) {
         property_count++;
     }

     qemu_put_be32(f, property_count);
 }

 /* Saves all available boot properties to snapshot.
  */
 static void
 boot_property_save( QEMUFile*  f, QemudService*  service, void*  opaque )
 {
     boot_property_save_count(f, _boot_properties);

     BootProperty *p = _boot_properties;
     for ( ; p; p = p->next) {
         if (boot_property_save_property(f, p)) {
             break;  /* abort on error */
         }
     }
 }

 /* Replaces the currently available boot properties by those stored
  * in a snapshot.
  */
 static int
 boot_property_load( QEMUFile*  f, QemudService*  service, void*  opaque )
 {
     int ret;

     /* remove properties from old run */
     boot_property_clear_all();

     /* load properties from snapshot */
     uint32_t i, property_count = qemu_get_be32(f);
     for (i = 0; i < property_count; i++) {
         if ((ret = boot_property_load_property(f))) {
             return ret;
         }
     }

     return 0;
 }

 #define SERVICE_NAME  "boot-properties"

 static void
 boot_property_client_recv( void*         opaque,
                            uint8_t*      msg,
                            int           msglen,
                            QemudClient*  client )
 {
     /* the 'list' command shall send all boot properties
      * to the client, then close the connection.
      */
     if (msglen == 4 && !memcmp(msg, "list", 4)) {
         BootProperty*  prop;
         for (prop = _boot_properties; prop != NULL; prop = prop->next) {
             qemud_client_send(client, (uint8_t*)prop->property, prop->length);
         }

         /* Send a NUL to signal the end of the list. */
         qemud_client_send(client, (uint8_t*)"", 1);

         return;
     }

     /* unknown command ? */
     D("%s: ignoring unknown command: %.*s", __FUNCTION__, msglen, msg);
 }

 static QemudClient*
 boot_property_service_connect( void*          opaque,
                                QemudService*  serv,
                                int            channel,
                                const char*    client_param )
 {
     QemudClient*  client;

     client = qemud_client_new( serv, channel, client_param, NULL,
                                boot_property_client_recv,
                                NULL, NULL, NULL );

     qemud_client_set_framing(client, 1);
     return client;
 }


 void
 boot_property_init_service( void )
 {
     if (!_inited) {
         QemudService*  serv = qemud_service_register( SERVICE_NAME,
                                                       1, NULL,
                                                       boot_property_service_connect,
                                                       boot_property_save,
                                                       boot_property_load);
         if (serv == NULL) {
             derror("could not register '%s' service", SERVICE_NAME);
             return;
         }
         D("registered '%s' qemud service", SERVICE_NAME);
     }
 }


 void
 boot_property_parse_option( const char*  param )
 {
     char* q = strchr(param,'=');
     const char* name;
     const char* value;
     int   namelen, valuelen, ret;

     if (q == NULL) {
         dwarning("boot property missing (=) separator: %s", param);
         return;
     }

     name    = param;
     namelen = q - param;

     value    = q+1;
     valuelen = strlen(name) - (namelen+1);

     ret = boot_property_add2(name, namelen, value, valuelen);
     if (ret < 0) {
         boot_property_raise_warning(ret, name, namelen, value, valuelen);
     }
 }
	/* Copyright (C) 2009 The Android Open Source Project
	**
	** This software is licensed under the terms of the GNU General Public
	** License version 2, as published by the Free Software Foundation, and
	** may be copied, distributed, and modified under those terms.
	**
	** This program is distributed in the hope that it will be useful,
	** but WITHOUT ANY WARRANTY; without even the implied warranty of
	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	** GNU General Public License for more details.
	*/

	#include "android/boot-properties.h"
	#include "android/utils/debug.h"
	#include "android/utils/system.h"
	#include "android/hw-qemud.h"
	#include "android/globals.h"

	#include "hw/hw.h"

	#define D(...) VERBOSE_PRINT(init,__VA_ARGS__)

	/* define T_ACTIVE to 1 to debug transport communications */
	#define T_ACTIVE 0

	#if T_ACTIVE
	#define T(...) VERBOSE_PRINT(init,__VA_ARGS__)
	#else
	#define T(...) ((void)0)
	#endif

	/* this code supports the list of system properties that will
	* be set on boot in the emulated system.
	*/

	typedef struct BootProperty {
	struct BootProperty* next;
	char* property;
	int length;
	} BootProperty;

	static BootProperty*
	boot_property_alloc( const char* name, int namelen,
	const char* value, int valuelen )
	{
	int length = namelen + 1 + valuelen;
	BootProperty* prop = android_alloc( sizeof(*prop) + length + 1 );
	char* p;

	prop->next = NULL;
	prop->property = p = (char*)(prop + 1);
	prop->length = length;

	memcpy( p, name, namelen );
	p += namelen;
	*p++ = '=';
	memcpy( p, value, valuelen );
	p += valuelen;
	*p = '\0';

	return prop;
	}

	static BootProperty* _boot_properties = NULL;
	/* address to store pointer to next new list element */
	static BootProperty** _boot_properties_tail = &_boot_properties;
	static int _inited;

	/* Clears all existing boot properties
	*/
	static void
	boot_property_clear_all()
	{
	/* free all elements of the linked list */
	BootProperty *p = _boot_properties;
	BootProperty *next = NULL;
	while (p) {
	next = p->next;
	AFREE(p);
	p = next;
	}

	/* reset list administration to initial state */
	_boot_properties = NULL;
	_boot_properties_tail = &_boot_properties;
	}

	/* Appends a new boot property to the end of the internal list.
	*/
	int
	boot_property_add2( const char* name, int namelen,
	const char* value, int valuelen )
	{
	BootProperty* prop;

	/* check the lengths
	*/
	if (namelen > PROPERTY_MAX_NAME)
	return -1;

	if (valuelen > PROPERTY_MAX_VALUE)
	return -2;

	/* check that there are not invalid characters in the
	* property name
	*/
	const char* reject = " =$*?'\"";
	int nn;

	for (nn = 0; nn < namelen; nn++) {
	if (strchr(reject, name[nn]) != NULL)
	return -3;
	}

	/* init service if needed */
	if (!_inited) {
	boot_property_init_service();
	_inited = 1;
	}

	D("Adding boot property: '%.s' = '%.s'",
	namelen, name, valuelen, value);

	/* add to the end of the internal list */
	prop = boot_property_alloc(name, namelen, value, valuelen);

	*_boot_properties_tail = prop;
	_boot_properties_tail = &prop->next;

	return 0;
	}

	/* Prints the warning string corresponding to the error code returned by
	* boot_propery_add2().
	*/
	static void
	boot_property_raise_warning( int ret, const char* name, int namelen,
	const char* value, int valuelen )
	{
	switch (ret) {
	case -1:
	dwarning("boot property name too long: '%.*s'",
	namelen, name);
	break;
	case -2:
	dwarning("boot property value too long: '%.*s'",
	valuelen, value);
	break;
	case -3:
	dwarning("boot property name contains invalid chars: %.*s",
	namelen, name);
	break;
	}
	}

	int
	boot_property_add( const char* name, const char* value )
	{
	int namelen = strlen(name);
	int valuelen = strlen(value);

	return boot_property_add2(name, namelen, value, valuelen);
	}

	/* Saves a single BootProperty to file.
	*/
	static int
	boot_property_save_property( QEMUFile f, BootProperty p )
	{
	/* split in key and value, so we can re-use boot_property_add (and its
	* sanity checks) when loading
	*/

	char *split = strchr(p->property, '=');
	if (split == NULL) {
	D("%s: save failed: illegal key/value pair \"%s\" (missing '=')\n",
	__FUNCTION__, p->property);
	qemu_file_set_error(f);
	return -1;
	}

	split = '\0'; / p->property is now "<key>\0<value>\0" */

	uint32_t key_buf_len = (split - p->property) + 1; // +1: '\0' terminator
	qemu_put_be32(f, key_buf_len);
	qemu_put_buffer(f, (uint8_t*) p->property, key_buf_len);

	uint32_t value_buf_len = p->length - key_buf_len + 1; // +1: '\0' terminator
	qemu_put_be32(f, value_buf_len);
	qemu_put_buffer(f, (uint8_t*) split + 1, value_buf_len);

	split = '='; / restore property to "<key>=<value>\0" */

	return 0;
	}

	/* Loads a single boot property from a snapshot file
	*/
	static int
	boot_property_load_property( QEMUFile *f )
	{
	int ret;

	/* load key */
	uint32_t key_buf_len = qemu_get_be32(f);
	char* key = android_alloc(key_buf_len);
	if ((ret = qemu_get_buffer(f, (uint8_t*)key, key_buf_len) != key_buf_len)) {
	D("%s: key load failed: expected %d bytes, got %d\n",
	__FUNCTION__, key_buf_len, ret);
	goto fail_key;
	}

	/* load value */
	uint32_t value_buf_len = qemu_get_be32(f);
	char* value = android_alloc(value_buf_len);
	if ((ret = qemu_get_buffer(f, (uint8_t*)value, value_buf_len) != value_buf_len)) {
	D("%s: value load failed: expected %d bytes, got %d\n",
	__FUNCTION__, value_buf_len, ret);
	goto fail_value;
	}

	/* add the property */
	ret = boot_property_add2(key, key_buf_len - 1, value, value_buf_len - 1);
	if (ret < 0) {
	D("%s: load failed: cannot add boot property (details follow)\n",
	__FUNCTION__);
	boot_property_raise_warning(ret, key, key_buf_len - 1, value, value_buf_len - 1);
	goto fail_value;
	}

	return 0;

	/* in case of errors, clean up before return */
	fail_value:
	AFREE(value);
	fail_key:
	AFREE(key);
	return -EIO;
	}

	/* Saves the number of available boot properties to file
	*/
	static void
	boot_property_save_count( QEMUFile* f, BootProperty* p )
	{
	uint32_t property_count = 0;
	for (; p; p = p->next) {
	property_count++;
	}

	qemu_put_be32(f, property_count);
	}

	/* Saves all available boot properties to snapshot.
	*/
	static void
	boot_property_save( QEMUFile* f, QemudService* service, void* opaque )
	{
	boot_property_save_count(f, _boot_properties);

	BootProperty *p = _boot_properties;
	for ( ; p; p = p->next) {
	if (boot_property_save_property(f, p)) {
	break; /* abort on error */
	}
	}
	}

	/* Replaces the currently available boot properties by those stored
	* in a snapshot.
	*/
	static int
	boot_property_load( QEMUFile* f, QemudService* service, void* opaque )
	{
	int ret;

	/* remove properties from old run */
	boot_property_clear_all();

	/* load properties from snapshot */
	uint32_t i, property_count = qemu_get_be32(f);
	for (i = 0; i < property_count; i++) {
	if ((ret = boot_property_load_property(f))) {
	return ret;
	}
	}

	return 0;
	}

	#define SERVICE_NAME "boot-properties"

	static void
	boot_property_client_recv( void* opaque,
	uint8_t* msg,
	int msglen,
	QemudClient* client )
	{
	/* the 'list' command shall send all boot properties
	* to the client, then close the connection.
	*/
	if (msglen == 4 && !memcmp(msg, "list", 4)) {
	BootProperty* prop;
	for (prop = _boot_properties; prop != NULL; prop = prop->next) {
	qemud_client_send(client, (uint8_t*)prop->property, prop->length);
	}

	/* Send a NUL to signal the end of the list. */
	qemud_client_send(client, (uint8_t*)"", 1);

	return;
	}

	/* unknown command ? */
	D("%s: ignoring unknown command: %.*s", __FUNCTION__, msglen, msg);
	}

	static QemudClient*
	boot_property_service_connect( void* opaque,
	QemudService* serv,
	int channel,
	const char* client_param )
	{
	QemudClient* client;

	client = qemud_client_new( serv, channel, client_param, NULL,
	boot_property_client_recv,
	NULL, NULL, NULL );

	qemud_client_set_framing(client, 1);
	return client;
	}


	void
	boot_property_init_service( void )
	{
	if (!_inited) {
	QemudService* serv = qemud_service_register( SERVICE_NAME,
	1, NULL,
	boot_property_service_connect,
	boot_property_save,
	boot_property_load);
	if (serv == NULL) {
	derror("could not register '%s' service", SERVICE_NAME);
	return;
	}
	D("registered '%s' qemud service", SERVICE_NAME);
	}
	}



	void
	boot_property_parse_option( const char* param )
	{
	char* q = strchr(param,'=');
	const char* name;
	const char* value;
	int namelen, valuelen, ret;

	if (q == NULL) {
	dwarning("boot property missing (=) separator: %s", param);
	return;
	}

	name = param;
	namelen = q - param;

	value = q+1;
	valuelen = strlen(name) - (namelen+1);

	ret = boot_property_add2(name, namelen, value, valuelen);
	if (ret < 0) {
	boot_property_raise_warning(ret, name, namelen, value, valuelen);
	}
	}