src2/hil2cap.c

   1 /*
   2 *  C Implementation: testovaci
   3 *
   4 * Description:
   5 *
   6 *
   7 * Author: root <root@ubuntu>, (C) 2008
   8 *
   9 * Copyright: See COPYING file that comes with this distribution
  10 *
  11 */
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <sys/ioctl.h>
  15 #include <errno.h>
  16 #include <stdint.h>
  17 #include "hil2cap.h"
  18 #include "hcidriver.h"
  19
  20
  21 expect_evt evt_array[MAX_CMD_STATE_REQUEST];
  22 int evt_id;
  23 int global_index;
  24 connection_hci connection,*p_connection=&connection;
  25
  26
  27 void add_evt_toarray(expect_evt *p_evt){ //fcn add the request at the end of array or replace the oldest request
  28         int i,sig=0,index=0;
  29         incoming_evt the_oldest=evt_array[0];
  30
  31         for(i=0;i<MAX_EVT_COUNT;i++){
  32                 if((evt_array[i].actual_status)==0 || evt_array[i].actual_status==3 ){
  33                         evt_array[i]=*p_evt;
  34                         sig=1;
  35                         global_index=i;
  36                         break;
  37                 }
  38                 if((evt_array[i].id) < the_oldest.id){ //the smallest id (oldest request) will stay here
  39                         the_oldest = evt_array[i];
  40                         index=i;
  41
  42                 }
  43         }
  44         if(!sig){
  45
  46                 evt_array[index]=*p_evt;
  47                 global_index=index;
  48         }
  49 }
  50
  51 int look_up_inarray(__u8 evt_code){
  52         int i,index=-1,oldestid=65535;
  53
  54         if(evt_array[global_index].evt_code == evt_code && evt_array[global_index].actual_status != DONE){
  55                 return global_index;
  56         }
  57         else{
  58                 for(i=0;i<MAX_CMD_STATE_REQUEST;i++){
  59                         if(evt_array[i].evt_code == evt_code && evt_array[i].actual_status != DONE){
  60                                 if(evt_array[i].id<oldestid){
  61                                         oldestid=evt_array[i].id;
  62                                         index=i;
  63                                 }
  64                         }
  65                 }
  66                 return index;
  67         }
  68 }
  69
  70
  71
  72 int tiny_bt_init(bt_device *p_device){
  73         expect_evt evt,*p_evt=&evt;
  74         req_state status = PERMANENT;
  75         evt_id=0;
  76         global_index=0;
  77         p_connection->con_id=0;
  78         p_connection->con_state=DISCONNECTED;
  79
  80         memset(p_evt,0,sizeof(evt));
  81         p_evt->actual_status=status;
  82         p_evt->id=evt_id++;
  83         p_evt->evt_type=EVT_CMD_STATUS;
  84
  85         add_evt_toarray(p_evt);
  86
  87 }
  88
  89 int tiny_bt_process(){
  90         int len,j,index;
  91         hci_event_hdr *p_hdr;
  92         __u8 recbuf[HCI_MAX_EVENT_SIZE],*p_recbuf;
  93
  94         len = hw_bt_read(recbuf);
  95
  96         if(len){
  97                         printf("Count of received bytes %d \n ",len);
  98                         for(j=0;j<len;j++){
  99                                 printf("%2.2X ",recbuf[j]);
 100                         }
 101                         printf("\n");
 102                         if(recbuf[0]==HCI_EVENT_PKT){
 103                                 p_hdr = (void *) (recbuf + 1);
 104                                 p_recbuf = (void *) (recbuf + (1 + HCI_EVENT_HDR_SIZE));
 105                                 if((index=look_up_inarray(p_hdr->evt))<0){
 106                                         printf("There is no awaiting evt like this\n");
 107                                         return -1;
 108                                 }
 109                                 else{
 110                                         if(evt_array[index].p_callback(evt_array[index].p_data, p_recbuf)<0){
 111                                                 printf("error with service rutine");
 112                                                 return -1;
 113                                         }
 114                                         if(evt_array[index].actual_status != PERMANENT){
 115                                                 evt_array[index].actual_status = DONE;
 116                                         }
 117                                 }
 118                                 return 1;
 119                         }
 120                         else if(recbuf[0]==2){
 121
 122                         }
 123                         else return 0; // 0 or -1
 124
 125                 }
 126                 else{
 127                         printf("There is nothing on socket %d \n",dd);
 128                         return 0;
 129                 }
 130
 131         return 0;
 132 }
 133
 134
 135 int tiny_bt_read_bd_addr(bd_address *p_dest, void (*callback_app_read_bd_addr)(bt_address *p_address)){
 136         expect_evt evt,*p_evt=&evt;
 137         req_state status = ESTABLISHED;
 138         read_bd_addr_data *p_data;
 139
 140         memset(p_evt,0,sizeof(evt));
 141         p_evt->actual_status=status;
 142         p_evt->id=evt_id++;
 143         p_evt->evt_type=EVT_CMD_COMPLETE;
 144         p_evt->req_opcode=READ_BD_ADDR_CMD_OP;
 145         p_evt->p_callback=&callback_hci_read_bd_addr;
 146
 147         p_data=malloc(sizeof(read_bd_addr_data));
 148         p_data->p_address=p_dest;
 149         p_data->callback_app_read_bd_addr=callback_app_read_bd_addr;
 150         p_evt->p_data=(void *)p_data;
 151
 152         add_evt_toarray(p_evt);
 153         if(send_hci_read_bd_addr_cmd()<0){
 154                 perror("send_hci_cmd error");
 155                 return -1;
 156         }
 157         return 0;
 158 }
 159
 160 int tiny_bt_read_local_name(char *p_name, void (*callback_app_read_local_name)(char *p_name)){
 161         expect_evt evt,*p_evt=&evt;
 162         req_state status = ESTABLISHED;
 163         read_local_name_data *p_data;
 164
 165         memset(p_evt,0,sizeof(evt));
 166         p_evt->actual_status=status;
 167         p_evt->id=evt_id++;
 168         p_evt->evt_type=EVT_CMD_COMPLETE;
 169         p_evt->req_opcode=READ_LOCAL_NAME_CMD_OP;
 170         p_evt->p_callback=callback_hci_read_local_name;
 171
 172         p_data=malloc(sizeof(read_local_name_data));
 173         p_data->p_name=p_name;
 174         p_data->callback_hci_read_local_name=callback_app_read_local_name;
 175         p_evt->p_data=(void *)p_data;
 176
 177         add_evt_toarray(p_evt);
 178         if(send_hci_read_local_name_cmd()<0){
 179                 perror("send_hci_cmd error");
 180                 return -1;
 181         }
 182         return 0;
 183 }
 184
 185 int tiny_bt_connect(bt_address *p_dest_addr, __u16 *p_handle, void (*callback_app_connection_complete)(__u16 *p_handle, bt_address *p_address)){
 186         expect_evt evt,*p_evt=&evt;
 187         req_state status = ESTABLISHED;
 188         connection_complete_data *p_data;
 189
 190         memset(p_evt,0,sizeof(evt));
 191         p_evt->actual_status=status;
 192         p_evt->id=evt_id++;
 193         p_evt->evt_type=EVT_CONN_COMPLETE;
 194         p_evt->req_opcode=CREATE_CONNECTION_CMD_OP;
 195         p_evt->p_callback=callback_hci_connection_complete;
 196
 197         p_data=malloc(sizeof(connection_complete_data));
 198         p_data->p_handle=p_handle;
 199         p_data->callback_app_connection_complete=callback_app_connection_complete;
 200         p_evt->p_data=(void *)p_data;
 201
 202         add_evt_toarray(p_evt);
 203         if(send_hci_create_connection_cmd(p_dest_addr)<0){
 204                 perror("send_hci_cmd error");
 205                 return -1;
 206         }
 207         return 0;
 208
 209 }
 210
 211 int tiny_bt_wait_for_connection(){
 212
 213 }
 214
 215
 216
 217
 218
 219
 220 int create_master_connection(connection_hci *p_connection){//establish connection and send a coutn of bytes every x second
 221          //array of open request which are in waiting state for appropriate event or answer
 222         p_connection->con_id=0;
 223         p_connection->con_state=DISCONNECTED;
 224
 225         p_connection->socket_fd=hci_open_device_sraw(p_connection->master.dev_id);
 226         if(l2cap_call_cmd(CREATE_CONNECTION_CMD_OP,p_connection->socket_fd,p_connection)<0){
 227                 printf("connection problem \n");
 228                 return -1;
 229         }
 230
 231
 232         return 0;
 233 }
 234
 235 int show_all_local_dev(struct hci_dev_info *master){ // and choose a master device which will initiate the connection
 236         int sock,i;
 237         struct hci_dev_list_req dlist,*p_dlist=&dlist;
 238         struct hci_dev_req *p_dreq;
 239
 240         p_dlist->dev_num=HCI_MAX_DEV;
 241         p_dreq=p_dlist->dev_req;
 242
 243         if((sock=socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI))<0){
 244                 return -1;
 245         }
 246
 247         if((ioctl(sock, HCIGETDEVLIST, (void *) p_dlist))<0){
 248                 return -1;
 249         }
 250         if(p_dlist->dev_num > 0){
 251                 struct hci_dev_info dev_array[p_dlist->dev_num];
 252                 for(i=0;i<p_dlist->dev_num;i++){
 253                         dev_array[i].dev_id=(p_dreq+i)->dev_id;
 254                         if(ioctl(sock, HCIGETDEVINFO, (void *) &dev_array[i])<0){
 255                                 printf("No info");
 256                                 continue;
 257                         }
 258                         int dd=hci_open_device(dev_array[i].dev_id);
 259                         if(l2cap_call_cmd(READ_BD_ADDR_CMD_OP,dd,&dev_array[i].bdaddr)< 0){
 260                                 printf("Error in call hci bd addr cmd \n");
 261                                 return -1;
 262                         }
 263                         if(l2cap_call_cmd(READ_LOCAL_NAME_CMD_OP,dd,&dev_array[i].name)< 0){
 264                                 printf("Error in call hci bd addr cmd \n");
 265                                 return -1;
 266                         }
 267                         //hci_close_dev(dev_array[i].dev_id);
 268                 }
 269                 *master = dev_array[0]; //I will take a first dev like a master
 270
 271         }
 272         else{
 273                 printf("There is no hci device \n");
 274                 return -1;
 275         }
 276         return 0;
 277
 278 }
 279
 280 int show_all_remote_dev(struct hci_dev_info *p_master, bt_address *p_remadrar, int *p_remd_count){
 281         int dd=hci_open_device(p_master->dev_id);
 282
 283         if((*p_remd_count=l2cap_call_cmd(INQUIRY_CMD_OP, dd, p_remadrar))< 0){
 284                                 printf("Error in call inquiry command \n");
 285                                 return -1;
 286                         }
 287         return 0;
 288
 289 }
 290
 291 int l2cap_call_cmd(__u16 ocf_ogf,int dd, void *p_param){
 292         cmd_state_request new_req,*p_new_req=&new_req;
 293         __u16 sw_opcode;
 294         int remd_count,ret_val;
 295         sw_opcode=swap_2_bytes(ocf_ogf);
 296         p_new_req->actual_status=ESTABLISHED;
 297         p_new_req->id=cmd_req_id++;
 298         p_new_req->req_opcode = ocf_ogf;
 299
 300         switch(ocf_ogf){
 301
 302         case READ_BD_ADDR_CMD_OP:
 303                 p_new_req->evt_code = EVT_CMD_COMPLETE;
 304                 p_new_req->p_serv_rutine=NULL;
 305
 306                 if(req_fcn_add(p_new_req)<0){
 307                         printf("Mistake with req array adding \n ");
 308                         return -1;
 309                 }
 310
 311                 if(call_hci_read_bd_addr_cmd(dd,(bt_address *)p_param,&sw_opcode)){
 312                         printf("Mistake with bt addr cmd \n ");
 313                         return -1;
 314                 }
 315                 req_fcn_remove();
 316                 return 0;
 317
 318         case READ_LOCAL_NAME_CMD_OP:
 319                 p_new_req->evt_code = EVT_CMD_COMPLETE;
 320                 p_new_req->p_serv_rutine=NULL;
 321
 322                 if(req_fcn_add(p_new_req)<0){
 323                         printf("Mistake with req array adding \n ");
 324                         return -1;
 325                 }
 326                 if(call_hci_read_local_name_cmd(dd,p_param,&sw_opcode)){
 327                         printf("Mistake with read local name cmd \n ");
 328                         return -1;
 329                 }
 330                 req_fcn_remove();
 331                 return 0;
 332
 333         case INQUIRY_CMD_OP:
 334
 335                 p_new_req->evt_code = EVT_INQUIRY_COMPLETE;
 336                 p_new_req->p_serv_rutine=NULL;
 337
 338                 if(req_fcn_add(p_new_req)<0){
 339                         printf("Mistake with req array adding \n ");
 340                         return -1;
 341                 }
 342                 if((remd_count=call_hci_inquiry_cmd(dd,p_param,&sw_opcode)) < 0){
 343                         printf("Mistake with inquiry cmd \n ");
 344                         return -1;
 345                 }
 346                 req_fcn_remove();
 347                 return remd_count;
 348
 349         case CREATE_CONNECTION_CMD_OP:
 350                 p_new_req->evt_code = EVT_CONN_COMPLETE;
 351                 p_new_req->p_serv_rutine=NULL;
 352
 353                 if(req_fcn_add(p_new_req)<0){
 354                         printf("Mistake with req array adding \n ");
 355                         return -1;
 356                 }
 357                 if((ret_val=call_hci_create_connection_cmd(dd, &(((connection_hci *)p_param)->slave.bdaddr), &sw_opcode)) < 0){
 358                         printf("Mistake with inquiry cmd \n ");
 359                         return -1;
 360                 }
 361                 ((connection_hci *)p_param)->handle=ret_val;
 362                 ((connection_hci *)p_param)->con_state=CONNECTED;
 363                 req_fcn_remove();
 364                 return 0;
 365         }
 366
 367         return 0;
 368 }
 369
 370
 371 int main(void){
 372         struct hci_dev_info master,*p_master=&master;
 373         bt_address remote_bd_addr_array[HCI_MAX_DEV];
 374         connection_hci connection,*p_connection=&connection;
 375         memset(remote_bd_addr_array,0,(sizeof(bt_address)*HCI_MAX_DEV));
 376         bt_address prefered;
 377         int remd_count,i;
 378         cmd_req_id=0;
 379         global_index=0;
 380         memset(array_req,0,(sizeof(cmd_state_request)*MAX_CMD_STATE_REQUEST));
 381         if(show_all_local_dev(p_master)<0){
 382                 printf("error no dev \n");
 383                 return -1;
 384         }
 385         if(show_all_remote_dev(p_master, remote_bd_addr_array, &remd_count)<0){
 386                 printf("error no remote dev \n");
 387                 return -1;
 388         }
 389         printf("All remote devices:\n");
 390         for(i=0;i<remd_count;i++){
 391                 printba(&remote_bd_addr_array[i]);
 392         }
 393         p_connection->master=master;
 394         p_connection->slave.bdaddr=remote_bd_addr_array[0];
 395         //fill_add(&prefered,0x31,0x16,0xCA,0x72,0x02,0x00);
 396         //p_connection->slave.bdaddr=prefered;
 397         if(create_master_connection(p_connection)<0){
 398                 printf("connection error");
 399                 return -1;
 400         }
 401
 402 return 0;
 403 }
 404