src/commandline_sdbd.c
src/usb_linux_client.c
src/usb_funcfs_client.c
- src/default_plugin_auth.c
- src/default_plugin_basic.c
- src/default_plugin_main.c
- src/default_plugin_event.c
- src/hashtable.c
- src/plugin.c
)
include(FindPkgConfig)
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __DEFAULT_PLUGIN_H
-#define __DEFAULT_PLUGIN_H
-
-extern eventfunc event_handler;
-
-int get_plugin_capability ( parameters* in, parameters* out );
-int verify_shell_cmd ( parameters* in, parameters* out );
-int convert_shell_cmd ( parameters* in, parameters* out );
-int verify_peer_ip ( parameters* in, parameters* out );
-int verify_sdbd_launch ( parameters* in, parameters* out );
-int verify_root_cmd ( parameters* in, parameters* out );
-int get_lock_state ( parameters* in, parameters* out );
-
-int auth_support ( parameters* in, parameters* out );
-int auth_get_key_file_paths ( parameters* in, parameters* out );
-
-int confirm_public_key ( parameters* in, int out_fd );
-
-void create_pwlock_thread();
-
-#endif // __DEFAULT_PLUGIN_H
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <stdlib.h>
-
-#define TRACE_TAG TRACE_SDB
-#include "log.h"
-
-#include "parameter.h"
-#include "sdbd_plugin.h"
-#include "default_plugin.h"
-
-int auth_support ( parameters* in, parameters* out )
-{
- if ( out == NULL ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- out->number_of_parameter = 1;
- out->array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
- out->array_of_parameter[0].type = type_int32;
- out->array_of_parameter[0].v_int32 = PLUGIN_RET_INVALID;
-
- return PLUGIN_CMD_SUCCESS;
-}
-
-int auth_get_key_file_paths ( parameters* in, parameters* out )
-{
- return PLUGIN_CMD_FAIL;
-
-}
-
-int confirm_public_key( parameters* in, int out_fd )
-{
- return PLUGIN_CMD_FAIL;
-}
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-#include <unistd.h>
-
-#define TRACE_TAG TRACE_SDB
-#include "log.h"
-
-#include "sdb.h"
-#include "parameter.h"
-#include "sdbd_plugin.h"
-#include "sdktools.h"
-
-#define LOG_DIRECTORY "/tmp"
-
-int get_plugin_capability ( parameters* in, parameters* out )
-{
- int capability;
-
- if ( in == NULL || in->number_of_parameter != 1 || in->array_of_parameter == NULL
- || in->array_of_parameter[0].type != type_int32 ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- if ( out == NULL ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- out->number_of_parameter = 1;
- out->array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
-
- capability = in->array_of_parameter[0].v_int32;
-
- if ( capability == CAPABILITY_SECURE ) {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_DISABLED );
- } else if ( capability == CAPABILITY_INTER_SHELL ) {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_ENABLED );
- } else if ( capability == CAPABILITY_FILESYNC ) {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_PUSHPULL );
- } else if ( capability == CAPABILITY_USB_PROTOCOL ) {
- if ( is_emulator() ) {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_DISABLED );
- } else {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_ENABLED );
- }
- } else if ( capability == CAPABILITY_SOCK_PROTOCOL ) {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_ENABLED );
- } else if ( capability == CAPABILITY_ROOT_ONOFF ) {
- if ( access ( "/bin/su", F_OK ) == 0 ) {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_ENABLED );
- } else {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_DISABLED );
- }
- } else if ( capability == CAPABILITY_CAN_LAUNCH ) {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_UNKNOWN );
- } else if ( capability == CAPABILITY_PLUGIN_VER ) {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_UNKNOWN );
- } else if ( capability == CAPABILITY_PRODUCT_VER ) {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_UNKNOWN );
- } else if ( capability == CAPABILITY_LOG_ENABLE ) {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", PLUGIN_RET_DISABLED );
- } else if ( capability == CAPABILITY_LOG_PATH ) {
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", LOG_DIRECTORY );
- } else {
- out->number_of_parameter = 0;
- free ( out->array_of_parameter );
- out->array_of_parameter = NULL;
- return PLUGIN_CMD_NOT_SUPPORT;
- }
-
- return PLUGIN_CMD_SUCCESS;
-}
-
-int verify_shell_cmd ( parameters* in, parameters* out )
-{
- if ( in == NULL || in->number_of_parameter != 1 || in->array_of_parameter == NULL
- || in->array_of_parameter[0].type != type_string ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- if ( out == NULL ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- D ( "shell command : %s\n", in->array_of_parameter[0].v_string.data );
-
- out->number_of_parameter = 1;
- out->array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
- out->array_of_parameter[0].type = type_int32;
- out->array_of_parameter[0].v_int32 = PLUGIN_RET_VALID;
-
- return PLUGIN_CMD_SUCCESS;
-}
-
-int convert_shell_cmd ( parameters* in, parameters* out )
-{
- if ( in == NULL || in->number_of_parameter != 1 || in->array_of_parameter == NULL
- || in->array_of_parameter[0].type != type_string ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- if ( out == NULL ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- D ( "shell command : %s\n", in->array_of_parameter[0].v_string.data );
-
- out->number_of_parameter = 1;
- out->array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
-
- make_string_parameter ( & ( out->array_of_parameter[0] ), "%s", in->array_of_parameter[0].v_string.data );
- return PLUGIN_CMD_SUCCESS;
-}
-
-int verify_peer_ip ( parameters* in, parameters* out )
-{
- if ( in == NULL || in->number_of_parameter != 1 || in->array_of_parameter == NULL
- || in->array_of_parameter[0].type != type_string ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- if ( out == NULL ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- D ( "shell command : %s\n", in->array_of_parameter[0].v_string.data );
-
- out->number_of_parameter = 1;
- out->array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
- out->array_of_parameter[0].type = type_int32;
- out->array_of_parameter[0].v_int32 = PLUGIN_RET_VALID;
-
- return PLUGIN_CMD_SUCCESS;
-}
-
-int verify_sdbd_launch ( parameters* in, parameters* out )
-{
- if ( out == NULL ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- out->number_of_parameter = 1;
- out->array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
- out->array_of_parameter[0].type = type_int32;
- out->array_of_parameter[0].v_int32 = PLUGIN_RET_VALID;
-
- return PLUGIN_CMD_SUCCESS;
-}
-
-int verify_root_cmd ( parameters* in, parameters* out )
-{
- if ( in == NULL || in->number_of_parameter != 1 || in->array_of_parameter == NULL
- || in->array_of_parameter[0].type != type_string ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- if ( out == NULL ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- D ( "shell command : %s\n", in->array_of_parameter[0].v_string.data );
-
- out->number_of_parameter = 1;
- out->array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
- out->array_of_parameter[0].type = type_int32;
-
- if ( verify_root_commands ( in->array_of_parameter[0].v_string.data ) ) {
- out->array_of_parameter[0].v_int32 = PLUGIN_RET_VALID;
- } else {
- out->array_of_parameter[0].v_int32 = PLUGIN_RET_INVALID;
- }
-
- return PLUGIN_CMD_SUCCESS;
-}
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <vconf.h>
-#include <glib.h>
-
-#define TRACE_TAG TRACE_SDB
-#include "log.h"
-
-#include "sysdeps.h"
-#include "sdbd_plugin.h"
-#include "default_plugin.h"
-
-int get_lock_state ( parameters* in, parameters* out )
-{
- if ( in == NULL || in->number_of_parameter != 1 || in->array_of_parameter == NULL
- || in->array_of_parameter[0].type != type_int32 ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- if ( out == NULL ) {
- D ( "Invalid argument\n" );
- return PLUGIN_CMD_FAIL;
- }
-
- D ( "shell command : %s\n", in->array_of_parameter[0].v_string.data );
-
- out->number_of_parameter = 1;
- out->array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
- out->array_of_parameter[0].type = type_int32;
- out->array_of_parameter[0].v_int32 = ( plugin_pwlocked() == 1 ) ? PLUGIN_RET_ON : PLUGIN_RET_OFF;
-
- return PLUGIN_CMD_SUCCESS;
-}
-
-int plugin_pwlocked ( void )
-{
- int pwlock_status = 0;
- int pwlock_type = 0;
-
- if ( vconf_get_int ( VCONFKEY_IDLE_LOCK_STATE, &pwlock_status ) ) {
- pwlock_status = 0;
- PLUGIN_LOG ( "failed to get pw lock status\n" );
- }
-#ifdef _WEARABLE
- PLUGIN_LOG ( "wearable lock applied\n" );
- // for wearable which uses different VCONF key (lock type)
- if ( vconf_get_int ( VCONFKEY_SETAPPL_PRIVACY_LOCK_TYPE_INT, &pwlock_type ) ) {
- pwlock_type = 0;
- PLUGIN_LOG ( "failed to get pw lock type\n" );
- }
- if ( ( pwlock_status == VCONFKEY_IDLE_LOCK ) && ( pwlock_type != SETTING_PRIVACY_LOCK_TYPE_NONE ) ) {
- PLUGIN_LOG ( "device has been locked\n" );
- return 1; // locked!
- }
-#else
- PLUGIN_LOG ( "mobile lock applied\n" );
- // for mobile
- if ( vconf_get_int ( VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &pwlock_type ) ) {
- pwlock_type = 0;
- PLUGIN_LOG ( "failed to get pw lock type\n" );
- }
- if ( pwlock_status == VCONFKEY_IDLE_LOCK && ( ( pwlock_type != SETTING_SCREEN_LOCK_TYPE_NONE ) && ( pwlock_type != SETTING_SCREEN_LOCK_TYPE_SWIPE ) ) ) {
- PLUGIN_LOG ( "device has been locked\n" );
- return 1; // locked!
- }
-#endif
- return 0; // unlocked!
-}
-
-static void pwlock_cb ( keynode_t *key, void* data )
-{
- PLUGIN_LOG ( "pwlock callback is issued\n" );
- int pwlocked = plugin_pwlocked();
-
- parameters* out = ( parameters* ) malloc ( sizeof ( parameters ) );
- out->number_of_parameter = 1;
- out->array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
- out->array_of_parameter[0].type = type_int32;
- out->array_of_parameter[0].v_int32 = ( pwlocked == 1 ) ? PLUGIN_RET_ON : PLUGIN_RET_OFF;
-
- event_handler ( PLUGIN_EVENT_PWLOCK, out );
-}
-
-static void register_pwlock_cb()
-{
- int ret = vconf_notify_key_changed ( VCONFKEY_IDLE_LOCK_STATE, pwlock_cb, NULL );
- if ( ret != 0 ) {
- PLUGIN_LOG ( "cannot register vconf callback.\n" );
- return;
- }
- PLUGIN_LOG ( "registered vconf callback\n" );
-}
-
-static void unregister_pwlock_cb()
-{
- int ret = vconf_ignore_key_changed ( VCONFKEY_IDLE_LOCK_STATE, pwlock_cb );
- if ( ret != 0 ) {
- PLUGIN_LOG ( "cannot unregister vconf callback.\n" );
- return;
- }
- PLUGIN_LOG ( "unregistered vconf callback\n" );
-}
-
-static void *pwlock_thread ( void *x )
-{
- GMainLoop *loop;
- loop = g_main_loop_new ( NULL, FALSE );
- register_pwlock_cb();
- g_main_loop_run ( loop );
- g_main_loop_unref ( loop );
- unregister_pwlock_cb();
- return NULL;
-}
-
-void create_pwlock_thread()
-{
- sdb_thread_t t;
- if ( sdb_thread_create ( &t, pwlock_thread, NULL ) ) {
- PLUGIN_LOG ( "cannot create_pwlock_thread.\n" );
- return;
- }
- PLUGIN_LOG ( "created pwlock_thread\n" );
-}
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "parameter.h"
-#include "sdbd_plugin.h"
-#include "default_plugin.h"
-#include "plugin.h"
-
-#define MAX_OUT_BUF_SIZE 128
-
-eventfunc event_handler = NULL;
-
-int default_plugin_init ( eventfunc event_cb, registerfunc register_func )
-{
- // default plugin do not need to register command
- // because unsupported command by plugin should be called with default plugin anyway
- event_handler = event_cb;
-
- if (is_supported_by_plugin(PLUGIN_EVENT_PWLOCK) == 0) {
- create_pwlock_thread();
- }
-
- return PLUGIN_CMD_SUCCESS;
-}
-
-int default_plugin_sync_proc ( int cmd, parameters* in, parameters* out )
-{
- int ret = PLUGIN_CMD_NOT_SUPPORT;
-
- if ( cmd == PLUGIN_SYNC_CMD_CAPABILITY ) {
- ret = get_plugin_capability ( in, out );
- } else if ( cmd == PLUGIN_SYNC_CMD_VERIFY_SHELLCMD ) {
- ret = verify_shell_cmd ( in, out );
- } else if ( cmd == PLUGIN_SYNC_CMD_CONVERT_SHELLCMD ) {
- ret = convert_shell_cmd ( in, out );
- } else if ( cmd == PLUGIN_SYNC_CMD_VERIFY_PEERIP ) {
- ret = verify_peer_ip ( in, out );
- } else if ( cmd == PLUGIN_SYNC_CMD_VERIFY_LAUNCH ) {
- ret = verify_sdbd_launch ( in, out );
- } else if ( cmd == PLUGIN_SYNC_CMD_VERIFY_ROOTCMD ) {
- ret = verify_root_cmd ( in, out );
- } else if ( cmd == PLUGIN_SYNC_CMD_AUTH_SUPPORT ) {
- ret = auth_support ( in, out );
- } else if ( cmd == PLUGIN_SYNC_CMD_AUTH_GET_KEY_FILEPATHS ) {
- ret = auth_get_key_file_paths ( in, out );
- } else if ( cmd == PLUGIN_SYNC_CMD_GET_LOCK_STATE ) {
- ret = get_lock_state ( in, out );
- } else {
- ret = PLUGIN_CMD_NOT_SUPPORT;
- }
-
- return ret;
-}
-
-int default_plugin_async_proc ( int cmd, parameters* in, int out_fd )
-{
- int ret = PLUGIN_CMD_NOT_SUPPORT;
-
- if ( cmd == PLUGIN_ASYNC_CMD_AUTH_CONFIRM_PUBLIC ) {
- ret = confirm_public_key ( in, out_fd );
- } else {
- ret = PLUGIN_CMD_NOT_SUPPORT;
- }
-
- return ret;
-}
-
#include <tzplatform_config.h>
#define TRACE_TAG TRACE_SYNC
-#include "log.h"
-
#include "sdb.h"
#include "file_sync_service.h"
#include "sdktools.h"
static int is_support_push()
{
- return (!strncmp(g_capabilities.filesync_support, PLUGIN_RET_PUSHPULL, strlen(PLUGIN_RET_PUSHPULL))
- || !strncmp(g_capabilities.filesync_support, PLUGIN_RET_PUSH, strlen(PLUGIN_RET_PUSH)));
+ return (!strncmp(g_capabilities.filesync_support, SDBD_CAP_RET_PUSHPULL, strlen(SDBD_CAP_RET_PUSHPULL))
+ || !strncmp(g_capabilities.filesync_support, SDBD_CAP_RET_PUSH, strlen(SDBD_CAP_RET_PUSH)));
}
static int is_support_pull()
{
- return (!strncmp(g_capabilities.filesync_support, PLUGIN_RET_PUSHPULL, strlen(PLUGIN_RET_PUSHPULL))
- || !strncmp(g_capabilities.filesync_support, PLUGIN_RET_PULL, strlen(PLUGIN_RET_PULL)));
+ return (!strncmp(g_capabilities.filesync_support, SDBD_CAP_RET_PUSHPULL, strlen(SDBD_CAP_RET_PUSHPULL))
+ || !strncmp(g_capabilities.filesync_support, SDBD_CAP_RET_PULL, strlen(SDBD_CAP_RET_PULL)));
}
static int do_send(int s, int noti_fd, char *path, char *buffer)
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <stdlib.h>
-
-#include "hashtable.h"
-
-static int get_hash_value ( hashtable* ht_table, int key )
-{
- return key % ht_table->size;
-}
-
-hashtable* hashtable_create ( ht_size_t tablesize )
-{
- hashtable* htable = NULL;
- int size = 0;
- int i;
-
- switch ( tablesize ) {
- case ht_size_7:
- size = 7;
- break;
- case ht_size_13:
- size = 13;
- break;
- case ht_size_31:
- size = 31;
- break;
- case ht_size_127:
- size = 127;
- break;
- case ht_size_1021:
- size = 1021;
- break;
- case ht_size_8191:
- size = 8191;
- break;
- default:
- size = 31;
- break;
- }
-
- // allocate hash table
- htable = ( hashtable* ) malloc ( sizeof ( hashtable ) );
- if ( htable == NULL ) {
- return NULL;
- }
-
- // allocate hash table entries
- htable->table = ( ht_entry** ) malloc ( sizeof ( ht_entry* ) * size );
- if ( htable->table == NULL ) {
- free ( htable );
- return NULL;
- }
-
- // initialize hash table entries
- for ( i = 0; i < size; i++ ) {
- htable->table[i] = NULL;
- }
-
- htable->size = size;
-
- return htable;
-}
-
-void hashtable_destroy ( hashtable* ht_table )
-{
- if ( ht_table != NULL ) {
- if ( ht_table->table != NULL ) {
- int i;
- for ( i = 0; i < ht_table->size; i++ ) {
- ht_entry* entry = ht_table->table[i];
- while ( entry != NULL ) {
- ht_entry* tmp = entry;
- entry = entry->next;
- free ( tmp );
- }
- }
-
- free ( ht_table->table );
- }
-
- free ( ht_table );
- }
-}
-
-// return 1 if put is successful
-// return 0 if put is failed
-int hashtable_put ( hashtable* ht_table, int key, int value )
-{
- int hash;
- ht_entry* entry = NULL;
-
- hash = get_hash_value ( ht_table, key );
- entry = ht_table->table[hash];
-
- while ( entry != NULL ) {
- if ( entry->key != key ) {
- entry = entry->next;
- } else {
- break;
- }
- }
-
- if ( entry != NULL ) {
- // there is a entry which has same key
- entry->value = value;
- } else {
- // there is no entry which has same key
-
- // make new entry
- ht_entry* new_entry = ( ht_entry* ) malloc ( sizeof ( ht_entry ) );
- if ( new_entry == NULL ) {
- return 0;
- }
- new_entry->key = key;
- new_entry->value = value;
-
- // add to entry list at first position
- new_entry->next = ht_table->table[hash];
- ht_table->table[hash] = new_entry;
- }
-
- return 1;
-}
-
-// return 1 if a entry is found in hash table
-// return 0 if a entry is not found in hash table
-// output value is stored in (*value)
-int hashtable_get ( hashtable* ht_table, int key, int* value )
-{
- int hash;
- ht_entry* entry = NULL;
-
- hash = get_hash_value ( ht_table, key );
- entry = ht_table->table[hash];
-
- while ( entry != NULL ) {
- if ( entry->key != key ) {
- entry = entry->next;
- } else {
- break;
- }
- }
-
- if ( entry != NULL ) {
- // there is a entry which has same key
- *value = entry->value;
- return 1;
- } else {
- // there is no entry which has same key
- return 0;
- }
-}
-
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __HASHTABLE_H
-#define __HASHTABLE_H
-
-typedef enum _hashtable_size {
- ht_size_7,
- ht_size_13,
- ht_size_31,
- ht_size_127,
- ht_size_1021,
- ht_size_8191
-} ht_size_t;
-
-typedef struct _ht_entry {
- int key;
- int value;
- struct _ht_entry* next;
-} ht_entry;
-
-typedef struct _hashtable {
- int size;
- ht_entry** table;
-} hashtable;
-
-hashtable* hashtable_create ( ht_size_t tablesize );
-void hashtable_destroy ( hashtable* ht_table );
-
-// return 1 if put is successful
-// return 0 if put is failed
-int hashtable_put ( hashtable* ht_table, int key, int value );
-
-// return 1 if a entry is found in hash table
-// return 0 if a entry is not found in hash table
-// output value is stored in (*value)
-int hashtable_get ( hashtable* ht_table, int key, int* value );
-
-#endif // __HASHTABLE_H
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __LOG_H
-#define __LOG_H
-
-#include <errno.h>
-
-#include "sysdeps.h"
-
-/* define SDB_TRACE to 1 to enable tracing support, or 0 to disable it */
-
-#define SDB_TRACE 1
-
-/* IMPORTANT: if you change the following list, don't
- * forget to update the corresponding 'tags' table in
- * the sdb_trace_init() function implemented in sdb.c
- */
-typedef enum {
- TRACE_SDB = 0,
- TRACE_SOCKETS,
- TRACE_PACKETS,
- TRACE_TRANSPORT,
- TRACE_RWX,
- TRACE_USB,
- TRACE_SYNC,
- TRACE_SYSDEPS,
- TRACE_JDWP,
- TRACE_SERVICES,
- TRACE_PROPERTIES,
- TRACE_SDKTOOLS
-} SdbTrace;
-
-#if SDB_TRACE
-
-#if !SDB_HOST
-/*
- * When running inside the emulator, guest's sdbd can connect to 'sdb-debug'
- * qemud service that can display sdb trace messages (on condition that emulator
- * has been started with '-debug sdb' option).
- */
-
-/* Delivers a trace message to the emulator via QEMU pipe. */
-void sdb_qemu_trace(const char* fmt, ...);
-
-/* Macro to use to send SDB trace messages to the emulator. */
-#define DQ(...) sdb_qemu_trace(__VA_ARGS__)
-#else
-#define DQ(...) ((void)0)
-#endif /* !SDB_HOST */
-
- extern int sdb_trace_mask;
- extern unsigned char sdb_trace_output_count;
- void sdb_trace_init(void);
-
-# define SDB_TRACING ((sdb_trace_mask & (1 << TRACE_TAG)) != 0)
-
- /* you must define TRACE_TAG before using this macro */
-# define D(...) \
- do { \
- if (SDB_TRACING) { \
- int save_errno = errno; \
- sdb_mutex_lock(&D_lock); \
- fprintf(stderr, "%s::%s():", \
- __FILE__, __FUNCTION__); \
- errno = save_errno; \
- fprintf(stderr, __VA_ARGS__ ); \
- fflush(stderr); \
- sdb_mutex_unlock(&D_lock); \
- errno = save_errno; \
- } \
- } while (0)
-# define DR(...) \
- do { \
- if (SDB_TRACING) { \
- int save_errno = errno; \
- sdb_mutex_lock(&D_lock); \
- errno = save_errno; \
- fprintf(stderr, __VA_ARGS__ ); \
- fflush(stderr); \
- sdb_mutex_unlock(&D_lock); \
- errno = save_errno; \
- } \
- } while (0)
-#else
-# define D(...) ((void)0)
-# define DR(...) ((void)0)
-# define SDB_TRACING 0
-#endif
-
-#endif // __LOG_H
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef SRC_PARAMETER_H_
-#define SRC_PARAMETER_H_
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-#include <stdint.h>
-
-typedef enum _datatype {
- type_int8,
- type_int16,
- type_int32,
- type_uint8,
- type_uint16,
- type_uint32,
- type_voidp,
- type_string,
- type_chunk
-} datatype;
-
-typedef struct _sstring {
- size_t length;
- char* data;
-} sstring;
-
-typedef struct _chunk {
- size_t size; // byte size of data
- unsigned char* data; // byte array of data
-} chunk;
-
-typedef struct _parameter {
- datatype type;
- union {
- int8_t v_int8;
- int16_t v_int16;
- int32_t v_int32;
- uint8_t v_uint8;
- uint16_t v_uint16;
- uint32_t v_uint32;
- void* v_pointer;
- sstring v_string;
- chunk v_chunk;
- };
-} parameter;
-
-typedef struct _parameters {
- size_t number_of_parameter;
- parameter* array_of_parameter;
-} parameters;
-
-#define MAX_OUT_BUF_SIZE 128
-
-static __inline__ void make_string_parameter ( parameter* pstring, const char* format, ... )
-{
- va_list args;
- char buf[MAX_OUT_BUF_SIZE];
-
- va_start ( args, format );
- vsnprintf ( buf, MAX_OUT_BUF_SIZE, format, args );
- va_end ( args );
-
- pstring->type = type_string;
- pstring->v_string.length = strlen ( buf );
- pstring->v_string.data = ( char* ) malloc ( pstring->v_string.length + 1 );
- strcpy ( pstring->v_string.data, buf );
-}
-
-static __inline__ void release_parameters ( parameters* param )
-{
- if ( param != NULL ) {
- int i;
- for ( i = 0; i < param->number_of_parameter; i++ ) {
- if ( param->array_of_parameter[i].type == type_string
- && param->array_of_parameter[i].v_string.data != NULL ) {
- free ( param->array_of_parameter[i].v_string.data );
- } else if ( param->array_of_parameter[i].type == type_chunk
- && param->array_of_parameter[i].v_chunk.data != NULL ) {
- free ( param->array_of_parameter[i].v_chunk.data );
- } else if ( param->array_of_parameter[i].type == type_voidp
- && param->array_of_parameter[i].v_pointer != NULL ) {
- free ( param->array_of_parameter[i].v_pointer );
- }
- }
- if ( param->array_of_parameter != NULL ) {
- free ( param->array_of_parameter );
- }
- }
-}
-
-#endif /* SRC_PARAMETER_H_ */
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <string.h>
-#include <dlfcn.h>
-
-#define TRACE_TAG TRACE_SDB
-#include "log.h"
-
-#include "sdb.h"
-
-#include "hashtable.h"
-#include "parameter.h"
-#include "plugin.h"
-#include "sdbd_plugin.h"
-
-static void* plugin_handle = NULL;
-
-PLUGIN_INIT plugin_init_proc = NULL;
-PLUGIN_SYNCHRONOUS_CMD_PROC plugin_sync_proc = NULL;
-PLUGIN_ASYNCHRONOUS_CMD_PROC plugin_async_proc = NULL;
-
-hashtable* plugin_cmd_hashtable = NULL;
-
-// handler of event to be detected by plugin
-int plugin_event_handler ( int event_type, parameters* data )
-{
- // TODO : implement event handler
- if ( event_type == PLUGIN_EVENT_PWLOCK || event_type == PLUGIN_EVENT_FMMLOCK ) {
- if ( data != NULL && data->number_of_parameter == 1 && data->array_of_parameter != NULL
- && data->array_of_parameter[0].type == type_int32 ) {
-
- if ( data->array_of_parameter[0].v_int32 == PLUGIN_RET_ON ) {
- // locked
- is_pwlocked = 1;
- } else {
- // unlocked
- is_pwlocked = 0;
- }
-
- send_device_status();
-
- if ( data != NULL ) {
- release_parameters ( data );
- free ( data );
- }
- }
- }
-
- return 0;
-}
-
-// register commands that are supported by plugin
-static int plugin_register_command ( int command, priority cmd_priority )
-{
- if ( plugin_cmd_hashtable ) {
- hashtable_put ( plugin_cmd_hashtable, command, cmd_priority );
- }
- return 0;
-}
-
-// return 0 if fail to load sdbd plugin (use default plugin)
-// return 1 if succeed to load sdbd plugin and get function pointer of plugin_init
-static int load_plugin_not_default()
-{
- plugin_init_proc = NULL;
- plugin_sync_proc = NULL;
- plugin_async_proc = NULL;
-
- plugin_handle = dlopen ( PLUGIN_PATH, RTLD_NOW );
- if ( plugin_handle == NULL ) {
- D ( "failed to dlopen(%s). error: %s\n", PLUGIN_PATH, dlerror() );
- return 0;
- }
-
- plugin_init_proc = dlsym ( plugin_handle, PLUGIN_PROC_NAME_INIT );
- if ( plugin_init_proc == NULL ) {
- D ( "failed to get the sdbd plugin init function. error: %s\n", dlerror() );
- dlclose ( plugin_handle );
- plugin_handle = NULL;
- return 0;
- }
-
- // if there is no implementation of plugin_sync_proc and plugin_async_proc,
- // then use default_plugin_sync_proc and default_plugin_async_proc
- plugin_sync_proc = dlsym ( plugin_handle, PLUGIN_PROC_NAME_SYNC_CMD );
- if ( plugin_sync_proc == NULL ) {
- plugin_sync_proc = default_plugin_sync_proc;
- }
-
- plugin_async_proc = dlsym ( plugin_handle, PLUGIN_PROC_NAME_ASYNC_CMD );
- if ( plugin_async_proc == NULL ) {
- plugin_async_proc = default_plugin_async_proc;
- }
-
- return 1;
-}
-
-void load_sdbd_plugin()
-{
- int ret;
-
- plugin_cmd_hashtable = hashtable_create ( ht_size_31 );
-
- ret = load_plugin_not_default();
- if ( ret == 0 ) {
- // use default plugin
- plugin_init_proc = default_plugin_init;
- plugin_sync_proc = default_plugin_sync_proc;
- plugin_async_proc = default_plugin_async_proc;
-
- D ( "using default plugin interface.\n" );
- } else {
- D ( "using sdbd plugin interface.(%s)\n", PLUGIN_PATH );
-
- plugin_init_proc ( plugin_event_handler, plugin_register_command );
- }
-
- // use default plugin feature for the commands or events that are not supported by plugin
- default_plugin_init ( plugin_event_handler, plugin_register_command );
-}
-
-void unload_sdbd_plugin()
-{
- if ( plugin_cmd_hashtable ) {
- hashtable_destroy ( plugin_cmd_hashtable );
- plugin_cmd_hashtable = NULL;
- }
-
- if ( plugin_handle ) {
- dlclose ( plugin_handle );
- plugin_handle = NULL;
- }
-}
-
-// return 1 if plugin support given command
-// return 0 if plugin does not support given command
-int is_supported_by_plugin ( int cmd )
-{
- int ret = 0;
-
- if ( plugin_cmd_hashtable ) {
- int value;
- ret = hashtable_get ( plugin_cmd_hashtable, cmd, &value );
- }
-
- return ret;
-}
-
-static int request_sync_cmd ( int cmd, parameters* in, parameters* out )
-{
- int ret, pr;
-
- out->number_of_parameter = 0;
- out->array_of_parameter = NULL;
-
- ret = hashtable_get ( plugin_cmd_hashtable, cmd, &pr );
- if ( ret == 1 ) {
- // supported by plugin
- ret = plugin_sync_proc ( cmd, in, out );
- if ( ret == PLUGIN_CMD_NOT_SUPPORT ) {
- // not supported by plugin
- ret = default_plugin_sync_proc ( cmd, in, out );
- }
- } else {
- // not supported by plugin
- ret = default_plugin_sync_proc ( cmd, in, out );
- }
-
- return ret;
-}
-
-
-// return 1 if succeed to get capability from plugin
-// return 0 otherwise
-int request_capability_to_plugin ( int cap, char* out_buf, unsigned int out_len )
-{
- int success = 0;
- int ret;
- parameters in, out;
-
- in.number_of_parameter = 1;
- in.array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
- in.array_of_parameter[0].type = type_int32;
- in.array_of_parameter[0].v_int32 = cap;
-
- ret = request_sync_cmd ( PLUGIN_SYNC_CMD_CAPABILITY, &in, &out );
- if ( ret == PLUGIN_CMD_SUCCESS ) {
- strncpy ( out_buf, out.array_of_parameter[0].v_string.data, out_len - 1 );
- out_buf[out_len - 1] = '\0';
- success = 1;
- release_parameters ( &out );
- }
-
- release_parameters ( &in );
- return success;
-}
-
-// return 1 if allowed by plugin (valid)
-// return 0 if disallowed by plugin (invalid)
-int request_validity_to_plugin ( int cmd, const char* in_buf )
-{
- int success = 0;
- int ret;
- parameters in, out;
-
- if ( in_buf != NULL ) {
- in.number_of_parameter = 1;
- in.array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
- in.array_of_parameter[0].type = type_string;
- in.array_of_parameter[0].v_string.length = strlen ( in_buf );
- in.array_of_parameter[0].v_string.data = strdup ( in_buf );
- } else {
- in.number_of_parameter = 0;
- in.array_of_parameter = NULL;
- }
-
- ret = request_sync_cmd ( cmd, &in, &out );
- if ( ret == PLUGIN_CMD_SUCCESS ) {
- success = ( out.array_of_parameter[0].v_int32 == PLUGIN_RET_VALID ) ? 1 : 0;
- release_parameters ( &out );
- }
-
- release_parameters ( &in );
- return success;
-}
-
-// return 1 if succeed to convert
-// return 0 otherwise
-int request_conversion_to_plugin ( int cmd, const char* in_buf, char* out_buf, unsigned int out_len )
-{
- int success = 0;
- int ret;
- parameters in, out;
-
- in.number_of_parameter = 1;
- in.array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
- in.array_of_parameter[0].type = type_string;
- in.array_of_parameter[0].v_string.length = strlen ( in_buf );
- in.array_of_parameter[0].v_string.data = strdup ( in_buf );
-
- ret = request_sync_cmd ( cmd, &in, &out );
- if ( ret == PLUGIN_CMD_SUCCESS ) {
- strncpy ( out_buf, out.array_of_parameter[0].v_string.data, out_len - 1 );
- out_buf[out_len - 1] = '\0';
- success = 1;
- release_parameters ( &out );
- }
-
- release_parameters ( &in );
- return success;
-}
-
-// return 1 if locked
-// return 0 if unlocked
-// return -1 if request failed
-int request_lock_state_to_plugin ( int lock_type )
-{
- int result = -1;
- int ret;
- parameters in, out;
-
- in.number_of_parameter = 1;
- in.array_of_parameter = ( parameter* ) malloc ( sizeof ( parameter ) );
- in.array_of_parameter[0].type = type_int32;
- in.array_of_parameter[0].v_int32 = lock_type;
-
- ret = request_sync_cmd ( PLUGIN_SYNC_CMD_GET_LOCK_STATE, &in, &out );
- if ( ret == PLUGIN_CMD_SUCCESS ) {
- if ( out.array_of_parameter[0].v_int32 == PLUGIN_RET_ON ) {
- result = 1;
- } else {
- result = 0;
- }
- is_pwlocked = result;
- release_parameters ( &out );
- }
-
- release_parameters ( &in );
-
- return result;
-}
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __PLUGIN_H
-#define __PLUGIN_H
-
-#include "sdbd_plugin.h"
-
-#define PLUGIN_PATH "/usr/lib/libsdbd_plugin.so"
-
-int default_plugin_init ( eventfunc event_cb, registerfunc register_func );
-int default_plugin_sync_proc ( int cmd, parameters* in, parameters* out );
-int default_plugin_async_proc ( int cmd, parameters* in, int out_fd );
-
-void load_sdbd_plugin();
-void unload_sdbd_plugin();
-
-// return 1 if plugin support given command
-// return 0 if plugin does not support given command
-int is_supported_by_plugin ( int cmd );
-
-// return 1 if succeed to get capability from plugin
-// return 0 otherwise
-int request_capability_to_plugin ( int cap, char* out_buf, unsigned int out_len );
-
-// return 1 if allowed by plugin (valid)
-// return 0 if disallowed by plugin (invalid)
-int request_validity_to_plugin ( int cmd, const char* in_buf );
-
-// return 1 if succeed to convert
-// return 0 otherwise
-int request_conversion_to_plugin ( int cmd, const char* in_buf, char* out_buf, unsigned int out_len );
-
-// return 1 if locked
-// return 0 if unlocked
-// return -1 if request failed
-int request_lock_state_to_plugin ( int lock_type );
-
-#endif //__PLUGIN_H
//#include "loghack.h"
#include "sysdeps.h"
#define TRACE_TAG TRACE_PROPERTIES
-#include "log.h"
-
#include "sdb.h"
#define HAVE_TIZEN_PROPERTY
#include <pthread.h> /* for pthread_once() */
#include <stdlib.h>
#include <stdio.h>
-#include <string.h>
#include <errno.h>
#ifndef D
#include <dlfcn.h>
#include "sysdeps.h"
-#include "log.h"
#include "sdb.h"
#include "strutils.h"
#if !SDB_HOST
#endif
#include "utils.h"
#include "sdktools.h"
-#include "plugin.h"
-#include "sdbd_plugin.h"
#if !SDB_HOST
#include <linux/prctl.h>
#include <system_info.h>
#include <vconf.h>
#include <glib.h>
+#include "utils.h"
#define PROC_CMDLINE_PATH "/proc/cmdline"
#define USB_SERIAL_PATH "/sys/class/usb_mode/usb0/iSerial"
#define SDB_DEFAULT_GROUPS_CNT ((sizeof(g_default_groups)/sizeof(g_default_groups[0]))-1)
int is_init_sdk_userinfo = 0;
-int is_pwlocked = 0; // 0 if unlocked, 1 otherwise
#if !SDB_HOST
SdbdCommandlineArgs sdbd_commandline_args;
}
}
+void* g_sdbd_plugin_handle = NULL;
+SDBD_PLUGIN_CMD_PROC_PTR sdbd_plugin_cmd_proc = NULL;
+
void handle_sig_term(int sig) {
#ifdef SDB_PIDPATH
if (access(SDB_PIDPATH, F_OK) == 0)
static int is_enable_sdbd_log()
{
- return (!strncmp(g_capabilities.log_enable, PLUGIN_RET_ENABLED, strlen(PLUGIN_RET_ENABLED)));
+ return (!strncmp(g_capabilities.log_enable, SDBD_CAP_RET_ENABLED, strlen(SDBD_CAP_RET_ENABLED)));
}
int sdb_trace_mask;
char device_name[256]={0,};
int r = 0;
int status = 0;
- if (request_lock_state_to_plugin(LOCKTYPE_PASSWORD) == 1) {
+ if (is_pwlocked()) {
status = 1;
t->connection_state = CS_PWLOCK;
}
#endif
}
-void send_device_status()
+static void send_device_status()
{
D("broadcast device status\n");
apacket* cp = get_apacket();
cp->msg.command = A_STAT;
- cp->msg.arg0 = is_pwlocked;
+ cp->msg.arg0 = is_pwlocked();
cp->msg.arg1 = 0;
broadcast_transport(cp);
break;
case A_OPEN: /* OPEN(local-id, 0, "destination") */
- if (request_lock_state_to_plugin(LOCKTYPE_PASSWORD) == 1 && t->connection_state == CS_PWLOCK) {
- // in case of already locked before get A_CNXN
+ if (is_pwlocked() && t->connection_state == CS_PWLOCK) { // in case of already locked before get A_CNXN
D("open failed due to password locked before get A_CNXN:%d\n", t->connection_state);
send_close(0, p->msg.arg0, t);
} else {
// if(required_pid > 0) {
// kill(required_pid, SIGKILL);
// }
-
- unload_sdbd_plugin();
+ if (g_sdbd_plugin_handle) {
+ dlclose(g_sdbd_plugin_handle);
+ g_sdbd_plugin_handle = NULL;
+ }
}
void start_logging(void)
#endif
}
+int is_pwlocked(void) {
+ int pwlock_status = 0;
+ int pwlock_type = 0;
+
+ if (vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &pwlock_status)) {
+ pwlock_status = 0;
+ D("failed to get pw lock status\n");
+ }
+#ifdef _WEARABLE
+ D("wearable lock applied\n");
+ // for wearable which uses different VCONF key (lock type)
+ if (vconf_get_int(VCONFKEY_SETAPPL_PRIVACY_LOCK_TYPE_INT, &pwlock_type)) {
+ pwlock_type = 0;
+ D("failed to get pw lock type\n");
+ }
+ if ((pwlock_status == VCONFKEY_IDLE_LOCK) && (pwlock_type != SETTING_PRIVACY_LOCK_TYPE_NONE)) {
+ D("device has been locked\n");
+ return 1; // locked!
+ }
+#else
+ D("mobile lock applied\n");
+ // for mobile
+ if (vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &pwlock_type)) {
+ pwlock_type = 0;
+ D("failed to get pw lock type\n");
+ }
+ if (pwlock_status == VCONFKEY_IDLE_LOCK && ((pwlock_type != SETTING_SCREEN_LOCK_TYPE_NONE) && (pwlock_type != SETTING_SCREEN_LOCK_TYPE_SWIPE))) {
+ D("device has been locked\n");
+ return 1; // locked!
+ }
+#endif
+ return 0; // unlocked!
+}
+
int should_drop_privileges() {
if (rootshell_mode == 1) { // if root, then don't drop
return 0;
return 1;
}
+static void pwlock_cb(keynode_t *key, void* data) {
+ D("pwlock callback is issued\n");
+ send_device_status();
+}
+
+void register_pwlock_cb() {
+ int ret = vconf_notify_key_changed(VCONFKEY_IDLE_LOCK_STATE, pwlock_cb, NULL);
+ if(ret != 0) {
+ D("cannot register vconf callback.\n");
+ return;
+ }
+ D("registered vconf callback\n");
+}
+
+void unregister_pwlock_cb() {
+ int ret = vconf_ignore_key_changed(VCONFKEY_IDLE_LOCK_STATE, pwlock_cb);
+ if(ret != 0) {
+ D("cannot unregister vconf callback.\n");
+ return;
+ }
+ D("unregistered vconf callback\n");
+}
+
+static void *pwlock_thread(void *x) {
+ GMainLoop *loop;
+ loop = g_main_loop_new(NULL, FALSE);
+ register_pwlock_cb();
+ g_main_loop_run(loop);
+ g_main_loop_unref(loop);
+ unregister_pwlock_cb();
+ return 0;
+}
+
+void create_pwlock_thread() {
+ sdb_thread_t t;
+ if(sdb_thread_create( &t, pwlock_thread, NULL)) {
+ D("cannot create_pwlock_thread.\n");
+ return;
+ }
+ D("created pwlock_thread\n");
+}
+
#include <dbus/dbus.h>
#include <dbus/dbus-glib.h>
#include <dbus/dbus-glib-lowlevel.h>
return 0;
}
+/* default plugin proc */
+static int get_plugin_capability(const char* in_buf, sdbd_plugin_param out) {
+ int ret = SDBD_PLUGIN_RET_NOT_SUPPORT;
+
+ if (in_buf == NULL) {
+ D("Invalid argument\n");
+ return SDBD_PLUGIN_RET_FAIL;
+ }
+
+ if (SDBD_CMP_CAP(in_buf, SECURE)) {
+ snprintf(out.data, out.len, "%s", SDBD_CAP_RET_DISABLED);
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+ } else if (SDBD_CMP_CAP(in_buf, INTER_SHELL)) {
+ snprintf(out.data, out.len, "%s", SDBD_CAP_RET_ENABLED);
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+ } else if (SDBD_CMP_CAP(in_buf, FILESYNC)) {
+ // - push : SDBD_CAP_RET_PUSH
+ // - pull : SDBD_CAP_RET_PULL
+ // - both : SDBD_CAP_RET_PUSHPULL
+ // - disabled : SDBD_CAP_RET_DISABLED
+ snprintf(out.data, out.len, "%s", SDBD_CAP_RET_PUSHPULL);
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+ } else if (SDBD_CMP_CAP(in_buf, USBPROTO)) {
+ if (is_emulator()) {
+ snprintf(out.data, out.len, "%s", SDBD_CAP_RET_DISABLED);
+ } else {
+ snprintf(out.data, out.len, "%s", SDBD_CAP_RET_ENABLED);
+ }
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+ } else if (SDBD_CMP_CAP(in_buf, SOCKPROTO)) {
+ if (is_emulator()) {
+ snprintf(out.data, out.len, "%s", SDBD_CAP_RET_ENABLED);
+ } else {
+ snprintf(out.data, out.len, "%s", SDBD_CAP_RET_ENABLED);
+ }
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+ } else if (SDBD_CMP_CAP(in_buf, ROOTONOFF)) {
+ if (access("/bin/su", F_OK) == 0) {
+ snprintf(out.data, out.len, "%s", SDBD_CAP_RET_ENABLED);
+ } else {
+ snprintf(out.data, out.len, "%s", SDBD_CAP_RET_DISABLED);
+ }
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+ } else if (SDBD_CMP_CAP(in_buf, CANLAUNCH)) {
+ snprintf(out.data, out.len, "%s", UNKNOWN);
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+ } else if (SDBD_CMP_CAP(in_buf, PLUGIN_VER)) {
+ snprintf(out.data, out.len, "%s", UNKNOWN);
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+ } else if (SDBD_CMP_CAP(in_buf, PRODUCT_VER)) {
+ snprintf(out.data, out.len, "%s", UNKNOWN);
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+ } else if (SDBD_CMP_CAP(in_buf, LOG_ENABLE)) {
+ snprintf(out.data, out.len, "%s", SDBD_CAP_RET_DISABLED);
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+ } else if (SDBD_CMP_CAP(in_buf, LOG_PATH)) {
+ snprintf(out.data, out.len, "%s", "/tmp");
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+ }
+
+ return ret;
+}
+
+static int verify_shell_cmd(const char* in_buf, sdbd_plugin_param out) {
+ int ret = SDBD_PLUGIN_RET_FAIL;
+
+ if (in_buf == NULL) {
+ D("Invalid argument\n");
+ return SDBD_PLUGIN_RET_FAIL;
+ }
+
+ D("shell command : %s\n", in_buf);
+
+ snprintf(out.data, out.len, "%s", SDBD_RET_VALID);
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+
+ return ret;
+}
+
+static int convert_shell_cmd(const char* in_buf, sdbd_plugin_param out) {
+ int ret = SDBD_PLUGIN_RET_FAIL;
+
+ if (in_buf == NULL) {
+ D("Invalid argument\n");
+ return SDBD_PLUGIN_RET_FAIL;
+ }
+
+ snprintf(out.data, out.len, "%s", in_buf);
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+
+ return ret;
+}
+
+static int verify_peer_ip(const char* in_buf, sdbd_plugin_param out) {
+ int ret = SDBD_PLUGIN_RET_FAIL;
+
+ if (in_buf == NULL) {
+ D("Invalid argument\n");
+ return SDBD_PLUGIN_RET_FAIL;
+ }
+
+ D("peer ip : %s\n", in_buf);
+
+ snprintf(out.data, out.len, "%s", SDBD_RET_VALID);
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+
+ return ret;
+}
+
+static int verify_sdbd_launch(const char* in_buf, sdbd_plugin_param out) {
+ snprintf(out.data, out.len, "%s", SDBD_RET_VALID);
+ return SDBD_PLUGIN_RET_SUCCESS;
+}
+
+static int verify_root_cmd(const char* in_buf, sdbd_plugin_param out) {
+ int ret = SDBD_PLUGIN_RET_FAIL;
+
+ if (in_buf == NULL) {
+ D("Invalid argument\n");
+ return SDBD_PLUGIN_RET_FAIL;
+ }
+
+ D("shell command : %s\n", in_buf);
+
+ if (verify_root_commands(in_buf)) {
+ snprintf(out.data, out.len, "%s", SDBD_RET_VALID);
+ } else {
+ snprintf(out.data, out.len, "%s", SDBD_RET_INVALID);
+ }
+ ret = SDBD_PLUGIN_RET_SUCCESS;
+
+ return ret;
+}
+
+static int get_shell_env(const char* in_buf, sdbd_plugin_param out) {
+ snprintf(out.data, out.len, "%s", "");
+ return SDBD_PLUGIN_RET_SUCCESS;
+}
+
+int default_cmd_proc(const char* cmd,
+ const char* in_buf, sdbd_plugin_param out) {
+ int ret = SDBD_PLUGIN_RET_NOT_SUPPORT;
+
+ /* Check the arguments */
+ if (cmd == NULL || out.data == NULL) {
+ D("Invalid argument\n");
+ return SDBD_PLUGIN_RET_FAIL;
+ }
+
+ D("handle the command : %s\n", cmd);
+
+ /* Handle the request from sdbd */
+ if (SDBD_CMP_CMD(cmd, PLUGIN_CAP)) {
+ ret = get_plugin_capability(in_buf, out);
+ } else if (SDBD_CMP_CMD(cmd, VERIFY_SHELLCMD)) {
+ ret = verify_shell_cmd(in_buf, out);
+ } else if (SDBD_CMP_CMD(cmd, CONV_SHELLCMD)) {
+ ret = convert_shell_cmd(in_buf, out);
+ } else if (SDBD_CMP_CMD(cmd, VERIFY_PEERIP)) {
+ ret = verify_peer_ip(in_buf, out);
+ } else if (SDBD_CMP_CMD(cmd, VERIFY_LAUNCH)) {
+ ret = verify_sdbd_launch(in_buf, out);
+ } else if (SDBD_CMP_CMD(cmd, VERIFY_ROOTCMD)) {
+ ret = verify_root_cmd(in_buf, out);
+ } else if (SDBD_CMP_CMD(cmd, SHELL_ENVVAR)) {
+ ret = get_shell_env(in_buf, out);
+ } else {
+ D("Not supported command : %s\n", cmd);
+ ret = SDBD_PLUGIN_RET_NOT_SUPPORT;
+ }
+
+ return ret;
+}
+
+int request_plugin_cmd(const char* cmd, const char* in_buf,
+ char *out_buf, unsigned int out_len)
+{
+ int ret = SDBD_PLUGIN_RET_FAIL;
+ sdbd_plugin_param out;
+
+ if (out_len > SDBD_PLUGIN_OUTBUF_MAX) {
+ D("invalid parameter : %s\n", cmd);
+ return 0;
+ }
+
+ out.data = out_buf;
+ out.len = out_len;
+
+ ret = sdbd_plugin_cmd_proc(cmd, in_buf, out);
+ if (ret == SDBD_PLUGIN_RET_FAIL) {
+ D("failed to request : %s\n", cmd);
+ return 0;
+ }
+ if (ret == SDBD_PLUGIN_RET_NOT_SUPPORT) {
+ // retry in default handler
+ ret = default_cmd_proc(cmd, in_buf, out);
+ if (ret == SDBD_PLUGIN_RET_FAIL) {
+ D("failed to request : %s\n", cmd);
+ return 0;
+ }
+ }
+
+ // add null character.
+ out_buf[out_len-1] = '\0';
+ D("return value: %s\n", out_buf);
+
+ return 1;
+}
+
+static void load_sdbd_plugin() {
+ sdbd_plugin_cmd_proc = NULL;
+
+ g_sdbd_plugin_handle = dlopen(SDBD_PLUGIN_PATH, RTLD_NOW);
+ if (!g_sdbd_plugin_handle) {
+ D("failed to dlopen(%s). error: %s\n", SDBD_PLUGIN_PATH, dlerror());
+ sdbd_plugin_cmd_proc = default_cmd_proc;
+ return;
+ }
+
+ sdbd_plugin_cmd_proc = dlsym(g_sdbd_plugin_handle, SDBD_PLUGIN_INTF);
+ if (!sdbd_plugin_cmd_proc) {
+ D("failed to get the sdbd plugin interface. error: %s\n", dlerror());
+ dlclose(g_sdbd_plugin_handle);
+ g_sdbd_plugin_handle = NULL;
+ sdbd_plugin_cmd_proc = default_cmd_proc;
+ return;
+ }
+
+ D("using sdbd plugin interface.(%s)\n", SDBD_PLUGIN_PATH);
+}
+
#define SDB_PW_GR_DEFAULT_SIZE (16*1024)
static long get_passwd_bufsize() {
long bufsize = 0;
if (is_emulator()) {
register_bootdone_cb();
}
+
+ create_pwlock_thread();
}
#endif /* !SDB_HOST */
+int request_plugin_verification(const char* cmd, const char* in_buf) {
+ char out_buf[32] = {0,};
+
+ if(!request_plugin_cmd(cmd, in_buf, out_buf, sizeof(out_buf))) {
+ D("failed to request plugin command. : %s\n", SDBD_CMD_VERIFY_LAUNCH);
+ return 0;
+ }
+
+ if (strlen(out_buf) == 7 && !strncmp(out_buf, SDBD_RET_INVALID, 7)) {
+ D("[%s] is NOT verified.\n", cmd);
+ return 0;
+ }
+
+ D("[%s] is verified.\n", cmd);
+ return 1;
+}
+
static void init_capabilities(void) {
int ret = -1;
char *value = NULL;
// Secure protocol support
- if(!request_capability_to_plugin(CAPABILITY_SECURE, g_capabilities.secure_protocol,
+ if(!request_plugin_cmd(SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_SECURE,
+ g_capabilities.secure_protocol,
sizeof(g_capabilities.secure_protocol))) {
- D("failed to request. (%d:%d) \n", PLUGIN_SYNC_CMD_CAPABILITY, CAPABILITY_SECURE);
+ D("failed to request. (%s:%s) \n", SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_SECURE);
snprintf(g_capabilities.secure_protocol, sizeof(g_capabilities.secure_protocol),
"%s", DISABLED);
}
// Interactive shell support
- if(!request_capability_to_plugin(CAPABILITY_INTER_SHELL, g_capabilities.intershell_support,
+ if(!request_plugin_cmd(SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_INTER_SHELL,
+ g_capabilities.intershell_support,
sizeof(g_capabilities.intershell_support))) {
- D("failed to request. (%d:%d) \n", PLUGIN_SYNC_CMD_CAPABILITY, CAPABILITY_INTER_SHELL);
+ D("failed to request. (%s:%s) \n", SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_INTER_SHELL);
snprintf(g_capabilities.intershell_support, sizeof(g_capabilities.intershell_support),
"%s", DISABLED);
}
// File push/pull support
- if(!request_capability_to_plugin(CAPABILITY_FILESYNC, g_capabilities.filesync_support,
+ if(!request_plugin_cmd(SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_FILESYNC,
+ g_capabilities.filesync_support,
sizeof(g_capabilities.filesync_support))) {
- D("failed to request. (%d:%d) \n", PLUGIN_SYNC_CMD_CAPABILITY, CAPABILITY_FILESYNC);
+ D("failed to request. (%s:%s) \n", SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_FILESYNC);
snprintf(g_capabilities.filesync_support, sizeof(g_capabilities.filesync_support),
"%s", DISABLED);
}
// USB protocol support
- if(!request_capability_to_plugin(CAPABILITY_USB_PROTOCOL, g_capabilities.usbproto_support,
+ if(!request_plugin_cmd(SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_USBPROTO,
+ g_capabilities.usbproto_support,
sizeof(g_capabilities.usbproto_support))) {
- D("failed to request. (%d:%d) \n", PLUGIN_SYNC_CMD_CAPABILITY, CAPABILITY_USB_PROTOCOL);
+ D("failed to request. (%s:%s) \n", SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_USBPROTO);
snprintf(g_capabilities.usbproto_support, sizeof(g_capabilities.usbproto_support),
"%s", DISABLED);
}
// Socket protocol support
- if(!request_capability_to_plugin(CAPABILITY_SOCK_PROTOCOL, g_capabilities.sockproto_support,
+ if(!request_plugin_cmd(SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_SOCKPROTO,
+ g_capabilities.sockproto_support,
sizeof(g_capabilities.sockproto_support))) {
- D("failed to request. (%d:%d) \n", PLUGIN_SYNC_CMD_CAPABILITY, CAPABILITY_SOCK_PROTOCOL);
+ D("failed to request. (%s:%s) \n", SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_SOCKPROTO);
snprintf(g_capabilities.sockproto_support, sizeof(g_capabilities.sockproto_support),
"%s", DISABLED);
}
// Root command support
- if(!request_capability_to_plugin(CAPABILITY_ROOT_ONOFF, g_capabilities.rootonoff_support,
+ if(!request_plugin_cmd(SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_ROOTONOFF,
+ g_capabilities.rootonoff_support,
sizeof(g_capabilities.rootonoff_support))) {
- D("failed to request. (%d:%d) \n", PLUGIN_SYNC_CMD_CAPABILITY, CAPABILITY_ROOT_ONOFF);
+ D("failed to request. (%s:%s) \n", SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_ROOTONOFF);
snprintf(g_capabilities.rootonoff_support, sizeof(g_capabilities.rootonoff_support),
"%s", DISABLED);
}
// Product version
- if(!request_capability_to_plugin(CAPABILITY_PRODUCT_VER, g_capabilities.product_version,
+ if(!request_plugin_cmd(SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_PRODUCT_VER,
+ g_capabilities.product_version,
sizeof(g_capabilities.product_version))) {
- D("failed to request. (%d:%d) \n", PLUGIN_SYNC_CMD_CAPABILITY, CAPABILITY_PRODUCT_VER);
+ D("failed to request. (%s:%s) \n", SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_PRODUCT_VER);
snprintf(g_capabilities.product_version, sizeof(g_capabilities.product_version),
"%s", UNKNOWN);
}
// Sdbd plugin version
- if(!request_capability_to_plugin(CAPABILITY_PLUGIN_VER, g_capabilities.sdbd_plugin_version,
+ if(!request_plugin_cmd(SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_PLUGIN_VER,
+ g_capabilities.sdbd_plugin_version,
sizeof(g_capabilities.sdbd_plugin_version))) {
- D("failed to request. (%d:%d) \n", PLUGIN_SYNC_CMD_CAPABILITY, CAPABILITY_PLUGIN_VER);
+ D("failed to request. (%s:%s) \n", SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_PLUGIN_VER);
snprintf(g_capabilities.sdbd_plugin_version, sizeof(g_capabilities.sdbd_plugin_version),
"%s", UNKNOWN);
}
// sdbd log enable
- if(!request_capability_to_plugin(CAPABILITY_LOG_ENABLE, g_capabilities.log_enable,
+ if(!request_plugin_cmd(SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_LOG_ENABLE,
+ g_capabilities.log_enable,
sizeof(g_capabilities.log_enable))) {
- D("failed to request. (%d:%d) \n", PLUGIN_SYNC_CMD_CAPABILITY, CAPABILITY_LOG_ENABLE);
+ D("failed to request. (%s:%s) \n", SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_LOG_ENABLE);
snprintf(g_capabilities.log_enable, sizeof(g_capabilities.log_enable),
"%s", DISABLED);
}
- // sdbd log path
- if(!request_capability_to_plugin(CAPABILITY_LOG_PATH, g_capabilities.log_path,
+ // sdbd log path
+ if(!request_plugin_cmd(SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_LOG_PATH,
+ g_capabilities.log_path,
sizeof(g_capabilities.log_path))) {
- D("failed to request. (%d:%d) \n", PLUGIN_SYNC_CMD_CAPABILITY, CAPABILITY_LOG_PATH);
+ D("failed to request. (%s:%s) \n", SDBD_CMD_PLUGIN_CAP, SDBD_CAP_TYPE_LOG_PATH);
snprintf(g_capabilities.log_path, sizeof(g_capabilities.log_path),
"%s", UNKNOWN);
}
static int is_support_usbproto()
{
- return (!strncmp(g_capabilities.usbproto_support, PLUGIN_RET_ENABLED, strlen(PLUGIN_RET_ENABLED)));
+ return (!strncmp(g_capabilities.usbproto_support, SDBD_CAP_RET_ENABLED, strlen(SDBD_CAP_RET_ENABLED)));
}
static int is_support_sockproto()
{
- return (!strncmp(g_capabilities.sockproto_support, PLUGIN_RET_ENABLED, strlen(PLUGIN_RET_ENABLED)));
+ return (!strncmp(g_capabilities.sockproto_support, SDBD_CAP_RET_ENABLED, strlen(SDBD_CAP_RET_ENABLED)));
}
#define EMULATOR_MODEL_NAME "Emulator"
check_emulator_or_device();
load_sdbd_plugin();
-
init_capabilities();
sdb_trace_init();
init_drop_privileges();
init_sdk_requirements();
- if (!request_validity_to_plugin(PLUGIN_SYNC_CMD_VERIFY_LAUNCH, NULL)) {
+ if (!request_plugin_verification(SDBD_CMD_VERIFY_LAUNCH, NULL)) {
D("sdbd should be launched in develop mode.\n");
return -1;
}
return sdb_main(0, DEFAULT_SDB_PORT);
#endif
}
-
#include "transport.h" /* readx(), writex() */
#include "fdevent.h"
+#include "sdbd_plugin.h"
#if !SDB_HOST
#include "commandline_sdbd.h"
#endif
} pcap;
extern pcap g_capabilities;
+#define SDBD_PLUGIN_PATH "/usr/lib/libsdbd_plugin.so"
+#define SDBD_PLUGIN_INTF "sdbd_plugin_cmd_proc"
+typedef int (*SDBD_PLUGIN_CMD_PROC_PTR)(const char*, const char*, sdbd_plugin_param);
+extern SDBD_PLUGIN_CMD_PROC_PTR sdbd_plugin_cmd_proc;
+int request_plugin_cmd(const char* cmd, const char* in_buf, char *out_buf, unsigned int out_len);
+int request_plugin_verification(const char* cmd, const char* in_buf);
+
void print_packet(const char *label, apacket *p);
asocket *find_local_socket(unsigned id);
extern int rootshell_mode; // 0: sdk user, 1: root
extern int booting_done; // 0: platform booting is in progess 1: platform booting is done
-// 1 if locked, 0 if unlocked
-extern int is_pwlocked;
-
// This is the users and groups config for the platform
#define SID_ROOT 0 /* traditional unix root user */
extern char* g_sdk_home_dir_env;
#endif
+int is_pwlocked(void);
int should_drop_privileges(void);
int set_sdk_user_privileges();
void set_root_privileges();
-void send_device_status();
int get_emulator_forward_port(void);
int get_emulator_name(char str[], int str_size);
int check_header(apacket *p);
int check_data(apacket *p);
+/* define SDB_TRACE to 1 to enable tracing support, or 0 to disable it */
+
+#define SDB_TRACE 1
+
+/* IMPORTANT: if you change the following list, don't
+ * forget to update the corresponding 'tags' table in
+ * the sdb_trace_init() function implemented in sdb.c
+ */
+typedef enum {
+ TRACE_SDB = 0,
+ TRACE_SOCKETS,
+ TRACE_PACKETS,
+ TRACE_TRANSPORT,
+ TRACE_RWX,
+ TRACE_USB,
+ TRACE_SYNC,
+ TRACE_SYSDEPS,
+ TRACE_JDWP,
+ TRACE_SERVICES,
+ TRACE_PROPERTIES,
+ TRACE_SDKTOOLS
+} SdbTrace;
+
+#if SDB_TRACE
+
+#if !SDB_HOST
+/*
+ * When running inside the emulator, guest's sdbd can connect to 'sdb-debug'
+ * qemud service that can display sdb trace messages (on condition that emulator
+ * has been started with '-debug sdb' option).
+ */
+
+/* Delivers a trace message to the emulator via QEMU pipe. */
+void sdb_qemu_trace(const char* fmt, ...);
+/* Macro to use to send SDB trace messages to the emulator. */
+#define DQ(...) sdb_qemu_trace(__VA_ARGS__)
+#else
+#define DQ(...) ((void)0)
+#endif /* !SDB_HOST */
+
+ extern int sdb_trace_mask;
+ extern unsigned char sdb_trace_output_count;
+ void sdb_trace_init(void);
+
+# define SDB_TRACING ((sdb_trace_mask & (1 << TRACE_TAG)) != 0)
+
+ /* you must define TRACE_TAG before using this macro */
+# define D(...) \
+ do { \
+ if (SDB_TRACING) { \
+ int save_errno = errno; \
+ sdb_mutex_lock(&D_lock); \
+ fprintf(stderr, "%s::%s():", \
+ __FILE__, __FUNCTION__); \
+ errno = save_errno; \
+ fprintf(stderr, __VA_ARGS__ ); \
+ fflush(stderr); \
+ sdb_mutex_unlock(&D_lock); \
+ errno = save_errno; \
+ } \
+ } while (0)
+# define DR(...) \
+ do { \
+ if (SDB_TRACING) { \
+ int save_errno = errno; \
+ sdb_mutex_lock(&D_lock); \
+ errno = save_errno; \
+ fprintf(stderr, __VA_ARGS__ ); \
+ fflush(stderr); \
+ sdb_mutex_unlock(&D_lock); \
+ errno = save_errno; \
+ } \
+ } while (0)
+#else
+# define D(...) ((void)0)
+# define DR(...) ((void)0)
+# define SDB_TRACING 0
+#endif
+
+
#if !TRACE_PACKETS
#define print_packet(tag,p) do {} while (0)
#endif
#endif
#define CHUNK_SIZE (64*1024)
-#define SDBD_SHELL_CMD_MAX 4096
int sendfailmsg(int fd, const char *reason);
int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s);
#ifndef __SDBD_PLUGIN_H
#define __SDBD_PLUGIN_H
-#include "parameter.h"
-
-// ===========================================================================
-// command && event definition
-// ===========================================================================
-
-// synchronous command
-#define PLUGIN_SYNC_CMD_CAPABILITY 1000
-#define PLUGIN_SYNC_CMD_VERIFY_SHELLCMD 1001
-#define PLUGIN_SYNC_CMD_CONVERT_SHELLCMD 1002
-#define PLUGIN_SYNC_CMD_VERIFY_PEERIP 1003
-#define PLUGIN_SYNC_CMD_VERIFY_LAUNCH 1004
-#define PLUGIN_SYNC_CMD_VERIFY_ROOTCMD 1005
-#define PLUGIN_SYNC_CMD_AUTH_SUPPORT 1006
-#define PLUGIN_SYNC_CMD_AUTH_GET_KEY_FILEPATHS 1007
-#define PLUGIN_SYNC_CMD_GET_LOCK_STATE 1008
-
-// asynchronous command
-#define PLUGIN_ASYNC_CMD_AUTH_CONFIRM_PUBLIC 2000
-
-// event
-#define PLUGIN_EVENT_PWLOCK 3000
-#define PLUGIN_EVENT_FMMLOCK 3001
-
-// message
-#define PLUGIN_MESSAGE_CONFIRM_PUBLIC 4000
-
-// ==============================================================================
-// capability definition
-// ==============================================================================
-#define CAPABILITY_SECURE 10000
-#define CAPABILITY_INTER_SHELL 10001
-#define CAPABILITY_FILESYNC 10002
-#define CAPABILITY_USB_PROTOCOL 10003
-#define CAPABILITY_SOCK_PROTOCOL 10004
-#define CAPABILITY_ROOT_ONOFF 10005
-#define CAPABILITY_CAN_LAUNCH 10006
-#define CAPABILITY_PLUGIN_VER 10007
-#define CAPABILITY_PRODUCT_VER 10008
-#define CAPABILITY_LOG_ENABLE 10009
-#define CAPABILITY_LOG_PATH 10010
-
-// ===============================================================================
-// priority definition
-// ===============================================================================
-typedef enum _priority {
- PRIORITY_VERYLOW,
- PRIORITY_LOW,
- PRIORITY_NORMAL,
- PRIORITY_HIGH,
- PRIORITY_VERYHIGH
-} priority;
-
-// ===============================================================================
-// misc.
-// ===============================================================================
-#define LOCKTYPE_PASSWORD 20000
-#define LOCKTYPE_FMM 20001
-
-// ===============================================================================
-// return value definition
-// ===============================================================================
-#define PLUGIN_RET_ON 10
-#define PLUGIN_RET_OFF 11
-#define PLUGIN_RET_VALID 12
-#define PLUGIN_RET_INVALID 13
-#define PLUGIN_CMD_SUCCESS 101
-#define PLUGIN_CMD_FAIL 102
-#define PLUGIN_CMD_NOT_SUPPORT 103
-
-#define PLUGIN_RET_UNKNOWN "unknown"
-#define PLUGIN_RET_ENABLED "enabled"
-#define PLUGIN_RET_DISABLED "disabled"
-#define PLUGIN_RET_PUSH "push"
-#define PLUGIN_RET_PULL "pull"
-#define PLUGIN_RET_PUSHPULL "pushpull"
-
-// ================================================================================
-// callback and interface function definition
-// ================================================================================
-
-// definition of callback functions (implemented by sdbd)
-typedef int ( *eventfunc ) ( int event_type, parameters* data );
-typedef int ( *registerfunc ) ( int command, priority cmd_priority );
-
-// definition of interface functions (implemented by plugin)
-#define PLUGIN_PROC_NAME_INIT "plugin_init"
-#define PLUGIN_PROC_NAME_SYNC_CMD "plugin_synchronous_cmd_proc"
-#define PLUGIN_PROC_NAME_ASYNC_CMD "plugin_asynchronous_cmd_proc"
-
-typedef int ( *PLUGIN_INIT ) ( eventfunc event_func_ptr, registerfunc register_cmd_func_ptr );
-typedef int ( *PLUGIN_SYNCHRONOUS_CMD_PROC ) ( int cmd, parameters* in, parameters* out );
-typedef int ( *PLUGIN_ASYNCHRONOUS_CMD_PROC ) ( int cmd, parameters* in, int out_fd );
-
-#define PLUGIN_LOG(...) \
- fprintf(stderr, "%s::%s():", __FILE__, __FUNCTION__); \
+#include <string.h>
+
+/* plugin commands */
+#define SDBD_CMD_PLUGIN_CAP "plugin_capability"
+#define SDBD_CMD_VERIFY_SHELLCMD "verify_shell_cmd"
+#define SDBD_CMD_CONV_SHELLCMD "convert_shell_cmd"
+#define SDBD_CMD_VERIFY_PEERIP "verify_peer_ip"
+#define SDBD_CMD_VERIFY_LAUNCH "verify_sdbd_launch"
+#define SDBD_CMD_VERIFY_ROOTCMD "verify_root_cmd"
+#define SDBD_CMD_SHELL_ENVVAR "sdbd_shell_env_var"
+
+/* plugin capabilities */
+#define SDBD_CAP_TYPE_SECURE "secure_protocol_support"
+#define SDBD_CAP_TYPE_INTER_SHELL "interactive_shell_support"
+#define SDBD_CAP_TYPE_FILESYNC "file_sync_support"
+#define SDBD_CAP_TYPE_USBPROTO "usb_protocol_support"
+#define SDBD_CAP_TYPE_SOCKPROTO "socket_protocol_support"
+#define SDBD_CAP_TYPE_ROOTONOFF "root_onoff_support"
+#define SDBD_CAP_TYPE_CANLAUNCH "can_launch_target"
+#define SDBD_CAP_TYPE_PLUGIN_VER "sdbd_plugin_version"
+#define SDBD_CAP_TYPE_PRODUCT_VER "product_version"
+#define SDBD_CAP_TYPE_LOG_ENABLE "sdbd_log_enable"
+#define SDBD_CAP_TYPE_LOG_PATH "sdbd_log_path"
+
+/* capability return string */
+#define SDBD_CAP_RET_ENABLED "enabled"
+#define SDBD_CAP_RET_DISABLED "disabled"
+#define SDBD_CAP_RET_PUSH "push"
+#define SDBD_CAP_RET_PULL "pull"
+#define SDBD_CAP_RET_PUSHPULL "pushpull"
+
+/* verification return string */
+#define SDBD_RET_VALID "valid"
+#define SDBD_RET_INVALID "invalid"
+
+/* proc interface return value */
+#define SDBD_PLUGIN_RET_SUCCESS (0)
+#define SDBD_PLUGIN_RET_FAIL (-1)
+#define SDBD_PLUGIN_RET_NOT_SUPPORT (-2)
+
+/* utility macro */
+#define SDBD_CMP_CMD(cmd, type) \
+ ((strlen(cmd) == strlen(SDBD_CMD_##type) \
+ && !strncmp(cmd, SDBD_CMD_##type, strlen(cmd)))?1:0)
+
+#define SDBD_CMP_CAP(cap, type) \
+ ((strlen(cap) == (strlen(SDBD_CAP_TYPE_##type)) \
+ && !strncmp(cap, SDBD_CAP_TYPE_##type, strlen(cap)))?1:0)
+
+/* out parameter structure */
+#define SDBD_SHELL_CMD_MAX 4096
+#define SDBD_PLUGIN_OUTBUF_MAX 4096
+typedef struct sdbd_plugin_param {
+ unsigned int len;
+ char *data;
+} sdbd_plugin_param;
+
+/* log system */
+// 1. set the environment value. : SDB_TRACE=all
+// 2. restart the sdbd deamon.
+// 3. log is output to the /tmp/sdbd-[date].txt
+#define SDBD_PLUGIN_LOG(...) \
+ fprintf(stderr, "%s::%s():", \
+ __FILE__, __FUNCTION__); \
fprintf(stderr, __VA_ARGS__);
-#endif // __SDBD_PLUGIN_H
+#endif
#include "sdktools.h"
#define TRACE_TAG TRACE_SERVICES
-#include "log.h"
-
#include "sdb.h"
#include "sdktools.h"
#include "strutils.h"
* limitations under the License.
*/
-#include <stdio.h>
#include <stdlib.h>
+#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include "sysdeps.h"
#define TRACE_TAG TRACE_SERVICES
-#include "log.h"
-
#include "sdb.h"
#include "file_sync_service.h"
#include <termios.h>
#include <sys/ioctl.h>
-#include "sdbd_plugin.h"
-#include "plugin.h"
-
typedef struct stinfo stinfo;
struct stinfo {
static int is_support_interactive_shell()
{
- return (!strncmp(g_capabilities.intershell_support, PLUGIN_RET_ENABLED, strlen(PLUGIN_RET_ENABLED)));
+ return (!strncmp(g_capabilities.intershell_support, SDBD_CAP_RET_ENABLED, strlen(SDBD_CAP_RET_ENABLED)));
}
#if 0
static int is_support_rootonoff()
{
- return (!strncmp(g_capabilities.rootonoff_support, PLUGIN_RET_ENABLED, strlen(PLUGIN_RET_ENABLED)));
+ return (!strncmp(g_capabilities.rootonoff_support, SDBD_CAP_RET_ENABLED, strlen(SDBD_CAP_RET_ENABLED)));
}
void rootshell_service(int fd, void *cookie)
}
if (should_drop_privileges()) {
- if (argv[2] != NULL && getuid() == 0 && request_validity_to_plugin(PLUGIN_SYNC_CMD_VERIFY_ROOTCMD, argv[2])) {
+ if (argv[2] != NULL && getuid() == 0 && request_plugin_verification(SDBD_CMD_VERIFY_ROOTCMD, argv[2])) {
// do nothing
D("sdb: executes root commands!!:%s\n", argv[2]);
} else {
if(name) { // in case of shell execution directly
// Check the shell command validation.
- if (!request_validity_to_plugin(PLUGIN_SYNC_CMD_VERIFY_SHELLCMD, name)) {
+ if (!request_plugin_verification(SDBD_CMD_VERIFY_SHELLCMD, name)) {
D("This shell command is invalid. (%s)\n", name);
return -1;
}
}
memset(new_cmd, 0, SDBD_SHELL_CMD_MAX);
- if(!request_conversion_to_plugin(PLUGIN_SYNC_CMD_CONVERT_SHELLCMD, name, new_cmd, SDBD_SHELL_CMD_MAX)) {
+ if(!request_plugin_cmd(SDBD_CMD_CONV_SHELLCMD, name, new_cmd, SDBD_SHELL_CMD_MAX)) {
D("Failed to convert the shell command. (%s)\n", name);
free(new_cmd);
return -1;
#include "sysdeps.h"
#define TRACE_TAG TRACE_SOCKETS
-#include "log.h"
-
#include "sdb.h"
#include "strutils.h"
#include "sysdeps.h"
#define TRACE_TAG TRACE_TRANSPORT
-#include "log.h"
-
#include "sdb.h"
static void transport_unref(atransport *t);
D("broadcast device transport:%d\n", t->connection_state);
apacket* ap = get_apacket();
copy_packet(ap, p);
+
send_packet(ap, t);
-
- if (ap->msg.command == A_STAT && ap->msg.arg1 == 0) {
- // lock state message
- if (ap->msg.arg0 == 0) {
- // unlocked
- t->connection_state = CS_DEVICE;
- } else {
- // locked
- t->connection_state = CS_PWLOCK;
- }
+ if (is_pwlocked()) {
+ t->connection_state = CS_PWLOCK;
+ } else {
+ t->connection_state = CS_DEVICE;
}
-
}
sdb_mutex_unlock(&transport_lock);
}
return 0;
}
}
-
#endif
#define TRACE_TAG TRACE_TRANSPORT
-#include "log.h"
-
#include "sdb.h"
#include "strutils.h"
#if !SDB_HOST
#include "commandline_sdbd.h"
#endif
-#include "sdbd_plugin.h"
-#include "plugin.h"
+#include "utils.h"
#ifdef HAVE_BIG_ENDIAN
#define H4(x) (((x) & 0xFF000000) >> 24) | (((x) & 0x00FF0000) >> 8) | (((x) & 0x0000FF00) << 8) | (((x) & 0x000000FF) << 24)
// Check the peer ip validation.
if (!is_emulator()
- && !request_validity_to_plugin(PLUGIN_SYNC_CMD_VERIFY_PEERIP, inet_ntoa(addr.sin_addr))) {
+ && !request_plugin_verification(SDBD_CMD_VERIFY_PEERIP, inet_ntoa(addr.sin_addr))) {
sdb_close(fd);
} else {
int ret = -1;
#include <sysdeps.h>
#define TRACE_TAG TRACE_TRANSPORT
-#include "log.h"
-
#include "sdb.h"
#ifdef HAVE_BIG_ENDIAN
#include "sysdeps.h"
#define TRACE_TAG TRACE_USB
-#include "log.h"
-
#include "sdb.h"
#define MAX_PACKET_SIZE_FS 64
#include "sysdeps.h"
#define TRACE_TAG TRACE_USB
-#include "log.h"
-
#include "sdb.h"
#include "sysdeps.h"
#define TRACE_TAG TRACE_USB
-#include "log.h"
-
#include "sdb.h"
projects / sdk / target / sdbd.git / commitdiff