mcs/Session.cc

   1 #include "Session.h"
   2 #include "macros.h"
   3
   4 namespace remote { namespace mcs {
   5
   6 Session::Session(int p_fd, sessionmapbyfd_t& p_clientMap )
   7         : FileDescriptor(p_fd),
   8           authenticated(false),
   9           message_in(),
  10           sessionMap(p_clientMap)
  11 {
  12         sessionMap[fd] = this;
  13         setSendTimeout( fd,0,500000); // 0.5 second host send timeout should be adequate
  14         // set keepalive options
  15         setKeepAlive( fd, 3, 120, 30);
  16         createSessionRecord();
  17 }
  18
  19 Session::~Session()
  20 {
  21         log("Closing client connection!\n");
  22         sessionMap.erase(fd);
  23         deleteSessionRecord();
  24 }
  25
  26 void Session::destroy(bool silent)
  27 {
  28
  29         motemapbykey_t::iterator mi;
  30         // release any controlled motes
  31         for ( mi = motes.begin() ; mi != motes.end(); mi++ )
  32         {
  33                 try
  34                 {
  35                         if (mi->second) mi->second->dropSession(false);
  36                 }
  37                 catch (mysqlpp::Exception e) // don't throw exceptions while destructing
  38                 {
  39                         if (silent)
  40                         {
  41                                 log("Exception while dropping mote client: %s - record not updated!\n",e.what());
  42                         }
  43                         else
  44                         {
  45                                 __THROW__(e.what());
  46                         }
  47                 }
  48         }
  49
  50         delete this;
  51 }
  52
  53 void Session::resetDb()
  54 {
  55         mysqlpp::Connection& sqlConn = dbConn.getConnection();
  56         mysqlpp::Query reset = sqlConn.query();
  57         reset << "delete from session";
  58         reset.parse();
  59         reset.execute();
  60 }
  61
  62 void Session::createSessionRecord()
  63 {
  64         // create a session record for this connection
  65         mysqlpp::Connection& sqlConn = dbConn.getConnection();
  66         mysqlpp::Result res;
  67         mysqlpp::Query query = sqlConn.query();
  68         query << "insert into session(auth) values (0)";
  69         query.parse();
  70         mysqlpp::ResNSel sqlres = query.execute();
  71         if (sqlres.success)
  72         {
  73                 session_id = sqlres.insert_id;
  74                 Message message;
  75                 MsgSession msgSession(session_id);
  76                 ClientMsg msg(msgSession);
  77                 message.sendMsg(fd,msg);
  78         }
  79         else
  80         {
  81                 delete this;
  82                 __THROW__ ("Failed to insert new session in database!\n");
  83         }
  84         query.reset();
  85 }
  86
  87 void Session::deleteSessionRecord()
  88 {
  89         mysqlpp::Connection& sqlConn = dbConn.getConnection();
  90         mysqlpp::Result res;
  91         mysqlpp::Query query = sqlConn.query();
  92         query << "delete from session where id = " << session_id;
  93         query.execute();
  94         query.reset();
  95         authenticated = false;
  96 }
  97
  98 bool Session::isAuthenticated()
  99 {
 100         if (authenticated) return true;
 101         // look up and verify the authentication in the database
 102         mysqlpp::Connection& sqlConn = dbConn.getConnection();
 103         mysqlpp::Result res;
 104         mysqlpp::Query query = sqlConn.query();
 105
 106         query << "select auth from session where id = " << session_id;
 107         res = query.store();
 108
 109         if ( res.num_rows() == 1 )
 110         {
 111                 authenticated = res.at(0)["auth"];
 112         }
 113         query.reset();
 114
 115         if (authenticated){ log("Client authenticated!\n");}
 116         else { log("Client not authenticated!\n"); }
 117         return authenticated;
 118 }
 119
 120 void Session::freeMote(dbkey_t mote_id)
 121 {
 122         Message message;
 123         motemapbykey_t::iterator mi;
 124         mi = motes.find(mote_id);
 125         if ( mi != motes.end() )
 126         {
 127                 motes.erase(mi);
 128                 MsgClientConfirm confirm( MSGCLIENTCOMMAND_DROPMOTECONTROL, SUCCESS, mote_id );
 129                 ClientMsg clientMsg(confirm);
 130                 message.sendMsg(fd,clientMsg);
 131         }
 132 }
 133
 134 void Session::confirm(dbkey_t mote_id, MsgPayload& moteMsg)
 135 {
 136         Message message;
 137         MsgClientConfirm confirm( MSGCLIENTCOMMAND_MOTEMESSAGE, SUCCESS, mote_id, moteMsg );
 138         ClientMsg clientMsg(confirm);
 139
 140         try {
 141                 message.sendMsg(fd,clientMsg);
 142         }
 143         catch (remote::protocols::MMSException e)
 144         {
 145                 log("Exception: %s\n",e.what());
 146                 this->destroy();
 147         }
 148 }
 149
 150 void Session::handleEvent(short events)
 151 {
 152         if ( (events & POLLHUP) || (events & POLLNVAL) ) __THROW__ ("Client connection closed by peer!");
 153         if ( (events & POLLIN) || (events & POLLPRI) )
 154         {
 155                 // no input is accepted before external authorization
 156                 if ( !isAuthenticated() )
 157                 {
 158                          __THROW__ ("Client not authenticated!\n");
 159                 }
 160
 161                 // wait for an entire message before continuing
 162                 if (!message_in.nonBlockingRecv(fd))
 163                 {
 164                          return;
 165                 }
 166
 167                 uint32_t msglen = message_in.getLength();
 168                 uint8_t* buffer = message_in.getData();
 169                 ClientMsg msg(buffer,msglen);
 170
 171                 switch (msg.getType())
 172                 {
 173                         case CLIENTMSG_CLIENTREQUEST:
 174                         {
 175                                 MsgClientRequest& msgClientRequest = msg.getClientRequest();
 176                                 handleClientRequest(msgClientRequest);
 177                                 break;
 178                         }
 179                         default:
 180                                 __THROW__ ("Invalid message type from client!");
 181                                 break;
 182                 }
 183
 184         }
 185         else if ( (events & POLLERR) || (events & POLLHUP) || (events & POLLNVAL) )
 186         {
 187                 __THROW__ ("Client connection closed.\n");
 188         }
 189 }
 190
 191 void Session::handleClientRequest(MsgClientRequest& request)
 192 {
 193         dbkey_t mote_id;
 194         motemapbykey_t::const_iterator mi;
 195         MsgMoteIdList& idlist = request.getMoteIdList();
 196
 197         while( idlist.getNextMoteId(mote_id) )
 198         {
 199                 // check the session id
 200                 switch ( request.getCommand() )
 201                 {
 202                         case MSGCLIENTCOMMAND_GETMOTECONTROL:
 203                 getMoteControl(mote_id);
 204                                 break;
 205                         case MSGCLIENTCOMMAND_DROPMOTECONTROL:
 206                 dropMoteControl(mote_id);
 207                                 break;
 208                         case MSGCLIENTCOMMAND_MOTEMESSAGE:
 209                                 handleMoteRequest(mote_id,request.getMoteMsg());
 210                                 break;
 211                         default:
 212                                 __THROW__ ("Got unknown request from client.\n");
 213                                 break;
 214                 }
 215         }
 216 }
 217
 218
 219 void Session::handleMoteRequest(dbkey_t mote_id,MsgPayload& request)
 220 {
 221
 222         motemapbykey_t::const_iterator mi;
 223
 224         mi = motes.find(mote_id);
 225
 226         if ( mi != motes.end() )
 227         {
 228                 mi->second->request(request);
 229         }
 230         else
 231         {
 232                 MsgClientConfirm confirm( MSGCLIENTCOMMAND_MOTEMESSAGE, MOTE_NOT_CONTROLLED, mote_id );
 233                 ClientMsg msg(confirm);
 234                 Message message;
 235                 message.sendMsg(fd,msg);
 236         }
 237 }
 238
 239 void Session::getMoteControl( dbkey_t mote_id )
 240 {
 241         Message message;
 242         Mote* mote;
 243         // figure out which mote is referred to
 244         Mote::getById(mote_id,this,&mote);
 245
 246         if (mote)
 247         {
 248                 motes[mote_id] = mote;
 249                 MsgClientConfirm confirm( MSGCLIENTCOMMAND_GETMOTECONTROL, SUCCESS, mote_id );
 250                 ClientMsg msg(confirm);
 251                 message.sendMsg(fd,msg);
 252         } else
 253         {
 254                 MsgClientConfirm confirm( MSGCLIENTCOMMAND_GETMOTECONTROL, FAILURE, mote_id );
 255                 ClientMsg msg(confirm);
 256                 message.sendMsg(fd,msg);
 257         }
 258 }
 259
 260 void Session::dropMoteControl(dbkey_t mote_id)
 261 {
 262         Message message;
 263         motemapbykey_t::const_iterator mi;
 264
 265         mi = motes.find(mote_id);
 266
 267         if ( mi != motes.end() )
 268         {
 269                 mi->second->dropSession();
 270                 // dropSession should invoke freeMote that confirms the drop request
 271         }
 272         else
 273         {
 274                 MsgClientConfirm confirm( MSGCLIENTCOMMAND_DROPMOTECONTROL, MOTE_NOT_CONTROLLED, mote_id );
 275                 ClientMsg msg(confirm);
 276                 message.sendMsg(fd,msg);
 277         }
 278
 279 }
 280
 281 }}