Line data    Source code

       1              : /*
       2              :  *    Copyright (c) 2021 Project CHIP Authors
       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              : #include <transport/SessionHolder.h>
      18              : 
      19              : #include <transport/SecureSession.h>
      20              : #include <transport/Session.h>
      21              : 
      22              : namespace chip {
      23              : 
      24         7533 : SessionHolder::~SessionHolder()
      25              : {
      26         7533 :     Release();
      27         7533 : }
      28              : 
      29            0 : SessionHolder::SessionHolder(const SessionHolder & that) : IntrusiveListNodeBase()
      30              : {
      31            0 :     mSession = that.mSession;
      32            0 :     if (mSession.HasValue())
      33              :     {
      34            0 :         mSession.Value()->AddHolder(*this);
      35              :     }
      36            0 : }
      37              : 
      38            0 : SessionHolder::SessionHolder(SessionHolder && that) : IntrusiveListNodeBase()
      39              : {
      40            0 :     mSession = that.mSession;
      41            0 :     if (mSession.HasValue())
      42              :     {
      43            0 :         mSession.Value()->AddHolder(*this);
      44              :     }
      45              : 
      46            0 :     that.Release();
      47            0 : }
      48              : 
      49          233 : SessionHolder & SessionHolder::operator=(const SessionHolder & that)
      50              : {
      51          233 :     Release();
      52              : 
      53          233 :     mSession = that.mSession;
      54          233 :     if (mSession.HasValue())
      55              :     {
      56          233 :         mSession.Value()->AddHolder(*this);
      57              :     }
      58              : 
      59          233 :     return *this;
      60              : }
      61              : 
      62           10 : SessionHolder & SessionHolder::operator=(SessionHolder && that)
      63              : {
      64           10 :     Release();
      65              : 
      66           10 :     mSession = that.mSession;
      67           10 :     if (mSession.HasValue())
      68              :     {
      69           10 :         mSession.Value()->AddHolder(*this);
      70              :     }
      71              : 
      72           10 :     that.Release();
      73              : 
      74           10 :     return *this;
      75              : }
      76              : 
      77           52 : bool SessionHolder::GrabPairingSession(const SessionHandle & session)
      78              : {
      79           52 :     Release();
      80              : 
      81           52 :     if (!session->IsSecureSession())
      82            0 :         return false;
      83              : 
      84           52 :     if (!session->AsSecureSession()->IsEstablishing())
      85            0 :         return false;
      86              : 
      87           52 :     GrabUnchecked(session);
      88           52 :     return true;
      89              : }
      90              : 
      91         8361 : bool SessionHolder::Grab(const SessionHandle & session)
      92              : {
      93         8361 :     Release();
      94              : 
      95         8361 :     if (!session->IsActiveSession())
      96            0 :         return false;
      97              : 
      98         8361 :     GrabUnchecked(session);
      99         8361 :     return true;
     100              : }
     101              : 
     102         8415 : void SessionHolder::GrabUnchecked(const SessionHandle & session)
     103              : {
     104         8415 :     VerifyOrDie(!mSession.HasValue());
     105         8415 :     mSession.Emplace(session.mSession);
     106         8415 :     session->AddHolder(*this);
     107         8415 : }
     108              : 
     109        17966 : void SessionHolder::Release()
     110              : {
     111        17966 :     if (mSession.HasValue())
     112              :     {
     113         8658 :         mSession.Value()->RemoveHolder(*this);
     114         8658 :         mSession.ClearValue();
     115              :     }
     116        17966 : }
     117              : 
     118              : } // namespace chip