src/sdb.h

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __SDB_H
  18 #define __SDB_H
  19
  20 #include <limits.h>
  21 #include <stdlib.h>
  22 #include <stddef.h>
  23
  24 #include "transport.h"  /* readx(), writex() */
  25 #include "fdevent.h"
  26 #include "commandline_sdbd.h"
  27 #include <tzplatform_config.h>
  28
  29 #define MAX_PAYLOAD_V1  (4*1024)
  30 #define MAX_PAYLOAD_V2  (256*1024)
  31 #define MAX_PAYLOAD     MAX_PAYLOAD_V2
  32
  33 #define A_SYNC 0x434e5953
  34 #define A_CNXN 0x4e584e43
  35 #define A_OPEN 0x4e45504f
  36 #define A_OKAY 0x59414b4f
  37 #define A_CLSE 0x45534c43
  38 #define A_WRTE 0x45545257
  39 #define A_STAT 0x54415453
  40 #define A_ENCR 0x40682018 // encryption 메시지
  41
  42 #ifdef SUPPORT_ENCRYPT
  43  #define ENCR_SET_ON_REQ 0 // encryption hello 메시지
  44  #define ENCR_SET_ON_OK 1 // encryption ack 메시지
  45  #define ENCR_SET_OFF 2 // encryption mode off 메시지
  46  #define ENCR_GET 3 // encryption status get 메시지
  47  #define ENCR_ON_FAIL 4 // encryption on 실패 메시지
  48  #define ENCR_OFF_FAIL 5 // encryption off 실패 메시지
  49  #define ENCR_ON 1 // encryption on 상태
  50  #define ENCR_OFF 0 // encryption off 상태
  51 #endif
  52
  53 #define A_VERSION 0x02000000        // SDB protocol version
  54
  55 #define SDB_VERSION_MAJOR 2         // Used for help/version information
  56 #define SDB_VERSION_MINOR 2         // Used for help/version information
  57 #define SDB_VERSION_PATCH 31        // Used for help/version information
  58
  59 #define SDB_SERVER_VERSION 0        // Increment this when we want to force users to start a new sdb server
  60
  61 typedef struct amessage amessage;
  62 typedef struct apacket apacket;
  63 typedef struct asocket asocket;
  64 typedef struct alistener alistener;
  65 typedef struct aservice aservice;
  66 typedef struct atransport atransport;
  67 typedef struct adisconnect  adisconnect;
  68 typedef struct usb_handle usb_handle;
  69
  70 struct amessage {
  71     unsigned command;       /* command identifier constant      */
  72     unsigned arg0;          /* first argument                   */
  73     unsigned arg1;          /* second argument                  */
  74     unsigned data_length;   /* length of payload (0 is allowed) */
  75     unsigned data_check;    /* checksum of data payload         */
  76     unsigned magic;         /* command ^ 0xffffffff             */
  77 };
  78
  79 struct apacket
  80 {
  81     apacket *next;
  82
  83     unsigned len;
  84     unsigned char *ptr;
  85
  86     amessage msg;
  87     unsigned char data[MAX_PAYLOAD];
  88 };
  89
  90 /* An asocket represents one half of a connection between a local and
  91 ** remote entity.  A local asocket is bound to a file descriptor.  A
  92 ** remote asocket is bound to the protocol engine.
  93 */
  94 struct asocket {
  95         /* chain pointers for the local/remote list of
  96         ** asockets that this asocket lives in
  97         */
  98     asocket *next;
  99     asocket *prev;
 100
 101         /* the unique identifier for this asocket
 102         */
 103     unsigned id;
 104
 105         /* flag: set when the socket's peer has closed
 106         ** but packets are still queued for delivery
 107         */
 108     int    closing;
 109
 110         /* the asocket we are connected to
 111         */
 112
 113     asocket *peer;
 114
 115         /* For local asockets, the fde is used to bind
 116         ** us to our fd event system.  For remote asockets
 117         ** these fields are not used.
 118         */
 119     fdevent fde;
 120     int fd;
 121
 122         /* queue of apackets waiting to be written
 123         */
 124     apacket *pkt_first;
 125     apacket *pkt_last;
 126
 127         /* enqueue is called by our peer when it has data
 128         ** for us.  It should return 0 if we can accept more
 129         ** data or 1 if not.  If we return 1, we must call
 130         ** peer->ready() when we once again are ready to
 131         ** receive data.
 132         */
 133     int (*enqueue)(asocket *s, apacket *pkt);
 134
 135         /* ready is called by the peer when it is ready for
 136         ** us to send data via enqueue again
 137         */
 138     void (*ready)(asocket *s);
 139
 140         /* close is called by the peer when it has gone away.
 141         ** we are not allowed to make any further calls on the
 142         ** peer once our close method is called.
 143         */
 144     void (*close)(asocket *s);
 145
 146         /* socket-type-specific extradata */
 147     void *extra;
 148
 149         /* A socket is bound to atransport */
 150     atransport *transport;
 151 };
 152
 153
 154 /* the adisconnect structure is used to record a callback that
 155 ** will be called whenever a transport is disconnected (e.g. by the user)
 156 ** this should be used to cleanup objects that depend on the
 157 ** transport (e.g. remote sockets, listeners, etc...)
 158 */
 159 struct  adisconnect
 160 {
 161     void        (*func)(void*  opaque, atransport*  t);
 162     void*         opaque;
 163     adisconnect*  next;
 164     adisconnect*  prev;
 165 };
 166
 167
 168 /* a transport object models the connection to a remote device or emulator
 169 ** there is one transport per connected device/emulator. a "local transport"
 170 ** connects through TCP (for the emulator), while a "usb transport" through
 171 ** USB (for real devices)
 172 **
 173 ** note that kTransportHost doesn't really correspond to a real transport
 174 ** object, it's a special value used to indicate that a client wants to
 175 ** connect to a service implemented within the SDB server itself.
 176 */
 177 typedef enum transport_type {
 178         kTransportUsb,
 179         kTransportLocal,
 180         kTransportAny,
 181         kTransportHost,
 182 } transport_type;
 183
 184 struct atransport
 185 {
 186     atransport *next;
 187     atransport *prev;
 188
 189     int (*read_from_remote)(apacket *p, atransport *t);
 190     int (*write_to_remote)(apacket *p, atransport *t);
 191     void (*close)(atransport *t);
 192     void (*kick)(atransport *t);
 193
 194     int fd;
 195     int transport_socket;
 196     fdevent transport_fde;
 197     int ref_count;
 198     unsigned sync_token;
 199     int connection_state;
 200     transport_type type;
 201
 202         /* usb handle or socket fd as needed */
 203     usb_handle *usb;
 204     int sfd;
 205
 206         /* used to identify transports for clients */
 207     char *serial;
 208     char *product;
 209     int sdb_port; // Use for emulators (local transport)
 210     char *device_name; // for connection explorer
 211
 212         /* a list of adisconnect callbacks called when the transport is kicked */
 213     int          kicked;
 214     adisconnect  disconnects;
 215     int protocol_version;
 216     size_t max_payload;
 217
 218 #ifdef SUPPORT_ENCRYPT
 219     unsigned encryption; // 해당 연결이 암호화 모드인지 확인하는 flag , 0 = no-encryption / 1 = encryption
 220     int sessionID; // 암호화 세션 ID, 암호화 map에 대한 key
 221 #endif
 222 };
 223
 224
 225 /* A listener is an entity which binds to a local port
 226 ** and, upon receiving a connection on that port, creates
 227 ** an asocket to connect the new local connection to a
 228 ** specific remote service.
 229 **
 230 ** TODO: some listeners read from the new connection to
 231 ** determine what exact service to connect to on the far
 232 ** side.
 233 */
 234 struct alistener
 235 {
 236     alistener *next;
 237     alistener *prev;
 238
 239     fdevent fde;
 240     int fd;
 241
 242     const char *local_name;
 243     const char *connect_to;
 244     atransport *transport;
 245     adisconnect  disconnect;
 246 };
 247
 248 #define BIT32 "32"
 249 #define BIT64 "64"
 250 #define UNKNOWN "unknown"
 251 #define INFOBUF_MAXLEN 64
 252 #define INFO_VERSION "2.2.0"
 253 typedef struct platform_info {
 254     char platform_info_version[INFOBUF_MAXLEN];
 255     char model_name[INFOBUF_MAXLEN]; // Emulator
 256     char platform_name[INFOBUF_MAXLEN]; // Tizen
 257     char platform_version[INFOBUF_MAXLEN]; // 2.2.1
 258     char profile_name[INFOBUF_MAXLEN]; // 2.2.1
 259 } pinfo;
 260
 261 #define ENABLED "enabled"
 262 #define DISABLED "disabled"
 263 #define NETCOREDBG_LOCATION "/usr/share/aul/dotnet.debugger"
 264 #define CAPBUF_SIZE 4096
 265 #define CAPBUF_ITEMSIZE 32
 266 #define CAPBUF_L_ITEMSIZE 256
 267 #define CAPBUF_LL_ITEMSIZE PATH_MAX
 268 #define SDBD_CAP_VERSION_MAJOR 1
 269 #define SDBD_CAP_VERSION_MINOR 0
 270 typedef struct platform_capabilities
 271 {
 272     char secure_protocol[CAPBUF_ITEMSIZE];      // enabled or disabled
 273     char intershell_support[CAPBUF_ITEMSIZE];   // enabled or disabled
 274     char filesync_support[CAPBUF_ITEMSIZE];     // push or pull or pushpull or disabled
 275     char rootonoff_support[CAPBUF_ITEMSIZE];    // enabled or disabled
 276     char zone_support[CAPBUF_ITEMSIZE];         // enabled or disabled
 277     char multiuser_support[CAPBUF_ITEMSIZE];    // enabled or disabled
 278     char syncwinsz_support[CAPBUF_ITEMSIZE];    // enabled or disabled
 279     char usbproto_support[CAPBUF_ITEMSIZE];     // enabled or disabled
 280     char sockproto_support[CAPBUF_ITEMSIZE];    // enabled or disabled
 281     char appcmd_support[CAPBUF_ITEMSIZE];       // enabled or disabled
 282     char encryption_support[CAPBUF_ITEMSIZE];   // enabled or disabled
 283     char appid2pid_support[CAPBUF_ITEMSIZE];    // enabled or disabled
 284     char pkgcmd_debugmode[CAPBUF_ITEMSIZE];     // enabled or disabled
 285     char root_permission[CAPBUF_ITEMSIZE];      // enabled or disabled
 286
 287     char log_enable[CAPBUF_ITEMSIZE];           // enabled or disabled
 288     char log_path[CAPBUF_LL_ITEMSIZE];          // path of sdbd log
 289
 290     char cpu_arch[CAPBUF_ITEMSIZE];             // cpu architecture (ex. x86)
 291     char profile_name[CAPBUF_ITEMSIZE];         // profile name (ex. mobile)
 292     char vendor_name[CAPBUF_ITEMSIZE];          // vendor name (ex. Tizen)
 293     char sdk_toolpath[CAPBUF_L_ITEMSIZE];       // sdk tool path
 294     char can_launch[CAPBUF_L_ITEMSIZE];         // target name
 295     char device_name[CAPBUF_ITEMSIZE];          // device name
 296     char netcoredbg_support[CAPBUF_ITEMSIZE];   // enabled or disabled
 297     char architecture[CAPBUF_ITEMSIZE];         // 32 or 64
 298
 299     char platform_version[CAPBUF_ITEMSIZE];     // platform version (ex. 2.3.0)
 300     char product_version[CAPBUF_ITEMSIZE];      // product version (ex. 1.0)
 301     char sdbd_version[CAPBUF_ITEMSIZE];         // sdbd version
 302     char sdbd_plugin_version[CAPBUF_ITEMSIZE];  // sdbd plugin version
 303     char sdbd_cap_version[CAPBUF_ITEMSIZE];     // capability version
 304 } pcap;
 305 extern pcap g_capabilities;
 306
 307 void print_packet(const char *label, apacket *p);
 308
 309 asocket *find_local_socket(unsigned id);
 310 void install_local_socket(asocket *s);
 311 void remove_socket(asocket *s);
 312 void close_all_sockets(atransport *t);
 313
 314 #define  LOCAL_CLIENT_PREFIX  "emulator-"
 315
 316 asocket *create_local_socket(int fd);
 317 asocket *create_local_service_socket(const char *destination);
 318
 319 asocket *create_remote_socket(unsigned id, atransport *t);
 320 void connect_to_remote(asocket *s, const char *destination);
 321 void connect_to_smartsocket(asocket *s);
 322 size_t asock_get_max_payload(asocket *s);
 323
 324 void fatal(const char *fmt, ...);
 325 void fatal_errno(const char *fmt, ...);
 326
 327 void handle_packet(apacket *p, atransport *t);
 328 void send_packet(apacket *p, atransport *t);
 329
 330 void get_my_path(char *s, size_t maxLen);
 331 int launch_server(int server_port);
 332 int sdb_main(int server_port);
 333
 334
 335 /* transports are ref-counted
 336 ** get_device_transport does an acquire on your behalf before returning
 337 */
 338 void init_transport_registration(void);
 339 int  list_transports(char *buf, size_t  bufsize);
 340 void update_transports(void);
 341 void broadcast_transport(apacket *p);
 342 int get_connected_count(transport_type type);
 343
 344 asocket*  create_device_tracker(void);
 345
 346 /* Obtain a transport from the available transports.
 347 ** If state is != CS_ANY, only transports in that state are considered.
 348 ** If serial is non-NULL then only the device with that serial will be chosen.
 349 ** If no suitable transport is found, error is set.
 350 */
 351 atransport *acquire_one_transport(int state, transport_type ttype, const char* serial, char **error_out);
 352 void   add_transport_disconnect( atransport*  t, adisconnect*  dis );
 353 void   remove_transport_disconnect( atransport*  t, adisconnect*  dis );
 354 void   run_transport_disconnects( atransport*  t );
 355 void   kick_transport( atransport*  t );
 356
 357 /* initialize a transport object's func pointers and state */
 358 void  init_socket_transport(atransport *t, int s, int port, int local);
 359 void init_usb_transport(atransport *t, usb_handle *usb, int state);
 360
 361 /* for MacOS X cleanup */
 362 void close_usb_devices();
 363
 364 /* cause new transports to be init'd and added to the list */
 365 void register_socket_transport(int s, const char *serial, int port, int local, const char *device_name);
 366
 367 /* these should only be used for the "sdb disconnect" command */
 368 void unregister_transport(atransport *t);
 369 void unregister_all_tcp_transports();
 370
 371 void register_usb_transport(usb_handle *h, const char *serial, unsigned writeable);
 372
 373 /* this should only be used for transports with connection_state == CS_NOPERM */
 374 void unregister_usb_transport(usb_handle *usb);
 375
 376 atransport *find_transport(const char *serial);
 377
 378 int service_to_fd(const char *name);
 379
 380 int       init_jdwp(void);
 381 asocket*  create_jdwp_service_socket();
 382 asocket*  create_jdwp_tracker_service_socket();
 383 int       create_jdwp_connection_fd(int  jdwp_pid);
 384
 385 typedef enum {
 386     BACKUP,
 387     RESTORE
 388 } BackupOperation;
 389 int backup_service(BackupOperation operation, char* args);
 390 void framebuffer_service(int fd, void *cookie);
 391 void log_service(int fd, void *cookie);
 392 void remount_service(int fd, void *cookie);
 393 char * get_log_file_path(const char * log_name);
 394
 395 extern int rootshell_mode; // 0: sdk user, 1: root
 396 extern int booting_done; // 0: platform booting is in progess 1: platform booting is done
 397
 398 // 1 if locked, 0 if unlocked
 399 extern int is_pwlocked;
 400
 401 // This is the users and groups config for the platform
 402
 403 #define SID_ROOT        0    /* traditional unix root user */
 404
 405 #define SDK_USER_NAME   tzplatform_getenv(TZ_SDK_USER_NAME)
 406 #define SDK_TOOL_PATH   tzplatform_getenv(TZ_SDK_TOOLS)
 407 #define STATIC_SDK_USER_ID      5001
 408 #define STATIC_SDK_GROUP_ID     100
 409 #define STATIC_SDK_HOME_DIR     "/home/owner"
 410 extern uid_t g_sdk_user_id;
 411 extern gid_t g_sdk_group_id;
 412 extern char* g_sdk_home_dir;
 413 extern char* g_sdk_home_dir_env;
 414
 415 #define ROOT_USER_NAME          "root"
 416 #define STATIC_ROOT_USER_ID       0
 417 #define STATIC_ROOT_GROUP_ID     0
 418 #define STATIC_ROOT_HOME_DIR     "/root"
 419 extern uid_t g_root_user_id;
 420 extern gid_t g_root_group_id;
 421 extern char* g_root_home_dir;
 422 extern char* g_root_home_dir_env;
 423
 424 int should_drop_privileges(void);
 425 void send_device_status();
 426 int set_sdk_user_privileges(int is_drop_capability_after_fork);
 427 int set_root_privileges();
 428
 429 int get_emulator_forward_port(void);
 430 int get_emulator_name(char str[], int str_size);
 431 int get_device_name(char str[], int str_size);
 432 int get_emulator_hostip(char str[], int str_size);
 433 int get_emulator_guestip(char str[], int str_size);
 434
 435 /* packet allocator */
 436 apacket *get_apacket(void);
 437 void put_apacket(apacket *p);
 438
 439 int check_header(apacket *p, atransport *t);
 440 int check_data(apacket *p);
 441
 442 #if !TRACE_PACKETS
 443 #define print_packet(tag,p) do {} while (0)
 444 #endif
 445
 446 #if SDB_HOST_ON_TARGET
 447 /* sdb and sdbd are coexisting on the target, so use 26099 for sdb
 448  * to avoid conflicting with sdbd's usage of 26098
 449  */
 450 #  define DEFAULT_SDB_PORT 26099 /* tizen specific */
 451 #else
 452 #  define DEFAULT_SDB_PORT 26099 /* tizen specific */
 453 #endif
 454
 455 #  define QEMU_FORWARD_IP "10.0.2.2"
 456
 457 #define DEFAULT_SDB_LOCAL_TRANSPORT_PORT 26101 /* tizen specific */
 458 #define DEFAULT_SENSORS_LOCAL_TRANSPORT_PORT 26103 /* tizen specific */
 459
 460 #define SDB_CLASS              0xff
 461 #define SDB_SUBCLASS           0x20 //0x42 /* tizen specific */
 462 #define SDB_PROTOCOL           0x02 //0x01 /* tizen specific */
 463
 464
 465 void local_init(int port);
 466 int  local_connect(int  port, const char *device_name);
 467 int  local_connect_arbitrary_ports(int console_port, int sdb_port, const char *device_name);
 468
 469 /* usb host/client interface */
 470 extern void (*usb_init)();
 471 extern void (*usb_cleanup)();
 472 extern int (*usb_write)(usb_handle *h, const void *data, int len);
 473 extern int (*usb_read)(usb_handle *h, void *data, size_t len);
 474 extern int (*usb_close)(usb_handle *h);
 475 extern void (*usb_kick)(usb_handle *h);
 476
 477 /* functionfs backend */
 478 void ffs_usb_init();
 479 void ffs_usb_cleanup();
 480 int ffs_usb_write(usb_handle *h, const void *data, int len);
 481 int ffs_usb_read(usb_handle *h, void *data, size_t len);
 482 int ffs_usb_close(usb_handle *h);
 483 void ffs_usb_kick(usb_handle *h);
 484
 485 /* kernel sdb gadget backend */
 486 void linux_usb_init();
 487 void linux_usb_cleanup();
 488 int linux_usb_write(usb_handle *h, const void *data, int len);
 489 int linux_usb_read(usb_handle *h, void *data, size_t len);
 490 int linux_usb_close(usb_handle *h);
 491 void linux_usb_kick(usb_handle *h);
 492
 493 unsigned host_to_le32(unsigned n);
 494 int sdb_commandline(int argc, char **argv);
 495
 496 int connection_state(atransport *t);
 497
 498 #define CS_ANY       -1
 499 #define CS_OFFLINE    0
 500 #define CS_BOOTLOADER 1
 501 #define CS_DEVICE     2
 502 #define CS_HOST       3
 503 #define CS_RECOVERY   4
 504 #define CS_NOPERM     5 /* Insufficient permissions to communicate with the device */
 505 #define CS_SIDELOAD   6
 506 #define CS_PWLOCK     10
 507
 508 extern int HOST;
 509 extern int SHELL_EXIT_NOTIFY_FD;
 510 extern SdbdCommandlineArgs sdbd_commandline_args;
 511
 512 #define CHUNK_SIZE (64*1024)
 513 #define SDBD_SHELL_CMD_MAX 4096
 514
 515 int sendfailmsg(int fd, const char *reason);
 516 int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s);
 517 int copy_packet(apacket* dest, apacket* src);
 518
 519 int is_emulator(void);
 520 #define DEFAULT_DEVICENAME "unknown"
 521
 522 #define USB_FUNCFS_SDB_PATH "/dev/usb-funcs/sdb/default/"
 523 #define USB_NODE_FILE "/dev/samsung_sdb"
 524 int create_subprocess(const char *cmd, pid_t *pid, char * const argv[], char * const envp[]);
 525 void get_env(char *key, char **env);
 526
 527 #define RESERVE_CAPABILITIES_AFTER_FORK 0
 528 #define DROP_CAPABILITIES_AFTER_FORK 1
 529
 530 extern int exit_cleanup_required;
 531 #endif