1 /*
2  * Copyright (C) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "obex_session.h"
17 #include <memory>
18 #include "log.h"
19 #include "obex_utils.h"
20 #include "obex_socket_transport.h"
21 
22 namespace OHOS {
23 namespace bluetooth {
ObexServerSession(ObexTransport & transport,bool isSupportSrm,utility::Dispatcher & dispatcher,std::function<int (ObexServerSession &)> removeFun,std::function<void (ObexServerSession &,bool)> setBusyFun)24 ObexServerSession::ObexServerSession(ObexTransport &transport, bool isSupportSrm, utility::Dispatcher &dispatcher,
25     std::function<int(ObexServerSession &)> removeFun, std::function<void(ObexServerSession &, bool)> setBusyFun)
26     : ObexSession(transport.GetRemoteAddress()),
27       transport_(transport),
28       isSupportSrm_(isSupportSrm),
29       dispatcher_(dispatcher),
30       removeFun_(std::move(removeFun)),
31       setBusyFun_(std::move(setBusyFun))
32 {}
33 
Disconnect()34 int ObexServerSession::Disconnect()
35 {
36     if (invalid_) {
37         return -1;
38     }
39     return removeFun_(*this);
40 }
41 
SendSimpleResponse(ObexRspCode rspCode) const42 int ObexServerSession::SendSimpleResponse(ObexRspCode rspCode) const
43 {
44     if (invalid_) {
45         return -1;
46     }
47     return SendResponse(*ObexHeader::CreateResponse(rspCode));
48 }
49 
SendResponse(ObexHeader & resp) const50 int ObexServerSession::SendResponse(ObexHeader &resp) const
51 {
52     OBEX_LOG_DEBUG("Call %{public}s", __PRETTY_FUNCTION__);
53     if (invalid_) {
54         return -1;
55     }
56     // Reset connect response's mtu
57     if (resp.GetFieldMaxPacketLength() != nullptr) {
58         resp.SetFieldMaxPacketLength(maxPacketLength_);
59     }
60     if (resp.GetFieldPacketLength() > maxPacketLength_) {
61         OBEX_LOG_ERROR("Error: Response packet length[%{public}d]>mtu[%{public}d].",
62             int(resp.GetFieldPacketLength()), int(maxPacketLength_));
63         return -1;
64     }
65     bool ret = transport_.Write(resp.Build()->GetPacket());
66     if (ret) {
67         return 0;
68     }
69     OBEX_LOG_ERROR("SendResponse error: Write ret = %{public}d", ret);
70     return -1;
71 }
72 
SendGetResponse(const ObexHeader & req,ObexHeader & resp,std::shared_ptr<ObexBodyObject> reader)73 int ObexServerSession::SendGetResponse(const ObexHeader &req, ObexHeader &resp, std::shared_ptr<ObexBodyObject> reader)
74 {
75     OBEX_LOG_DEBUG("Call %{public}s", __PRETTY_FUNCTION__);
76     if (invalid_) {
77         return -1;
78     }
79     if (resp.HasHeader(ObexHeader::BODY) || resp.HasHeader(ObexHeader::END_OF_BODY)) {
80         OBEX_LOG_ERROR("Error: Can't include body/end-of-body header in this method.");
81         return -1;
82     }
83     if (resp.GetFieldCode() != static_cast<uint8_t>(ObexRspCode::SUCCESS) &&
84         resp.GetFieldCode() != static_cast<uint8_t>(ObexRspCode::CONTINUE)) {
85         return SendResponse(resp);
86     }
87     if (!reader) {
88         if (isSupportSrm_ && req.GetItemSrm()) {
89             resp.AppendItemSrm(true);
90         }
91         return SendResponse(resp);
92     }
93     sendObject_ = std::make_unique<ObexServerSendObject>(req, resp, reader, maxPacketLength_, isSupportSrm_);
94 
95     sendObject_->SetStartBodyResp(req.GetFieldCode() == static_cast<uint8_t>(ObexOpeId::GET_FINAL));
96     auto resp2 = sendObject_->GetNextRespHeader();
97     if (resp2 == nullptr) {
98         OBEX_LOG_ERROR("SendGetResponse: resp is null!");
99         sendObject_ = nullptr;
100         return -1;
101     }
102     int ret = SendResponse(*resp2);
103     if (ret != 0) {
104         sendObject_ = nullptr;
105         return ret;
106     }
107     if (resp2->GetFieldCode() != static_cast<uint8_t>(ObexRspCode::CONTINUE)) {
108         OBEX_LOG_DEBUG("Send done with first packet, reset sendObject_ to null");
109         sendObject_ = nullptr;
110         return ret;
111     }
112     dispatcher_.PostTask(std::bind(setBusyFun_, std::ref(*this), true));
113     if (sendObject_->IsSupportSrmMode() && sendObject_->IsSrmEnable() && !sendObject_->IsSrmWait()) {
114         ret = SendSrmResponse();
115     }
116     return ret;
117 }
118 
ProcessSendSrmResponse()119 int ObexServerSession::ProcessSendSrmResponse()
120 {
121     OBEX_LOG_DEBUG("Call %{public}s", __PRETTY_FUNCTION__);
122     if (invalid_) {
123         return -1;
124     }
125     if (!sendObject_) {
126         return -1;
127     }
128     sendObject_->SetSrmSending();
129     if (sendObject_->IsBusy()) {
130         OBEX_LOG_DEBUG("ProcessSendSrmResponse: Transport is busy, waiting...");
131         return 0;
132     }
133     auto nextReqHdr = sendObject_->GetNextRespHeader();
134     if (nextReqHdr == nullptr) {
135         OBEX_LOG_ERROR("ProcessSendSrmResponse: nextReqHdr is null!");
136         if (!sendObject_->IsDone()) {
137             sendObject_ = nullptr;
138         }
139         nextReqHdr = ObexHeader::CreateResponse(ObexRspCode::INTERNAL_SERVER_ERROR);
140     }
141     int ret = SendResponse(*nextReqHdr);
142     if (ret != 0) {
143         sendObject_ = nullptr;
144         return ret;
145     }
146     if (nextReqHdr->GetFieldCode() == static_cast<uint8_t>(ObexRspCode::CONTINUE)) {
147         OBEX_LOG_DEBUG("ProcessSendSrmResponse: CONTINUE");
148         dispatcher_.PostTask(std::bind(&ObexServerSession::ProcessSendSrmResponse, this));
149     } else if (nextReqHdr->GetFieldCode() == static_cast<uint8_t>(ObexRspCode::SUCCESS)) {
150         sendObject_ = nullptr;
151         OBEX_LOG_DEBUG("ProcessSendSrmResponse: Server send with SRM MODE END");
152         setBusyFun_(*this, false);
153     } else {
154         sendObject_ = nullptr;
155         OBEX_LOG_ERROR("ProcessSendSrmResponse: SRM MODE END WITH RESPCODE 0x%02X", nextReqHdr->GetFieldCode());
156         setBusyFun_(*this, false);
157     }
158     return ret;
159 }
160 
SendSrmResponse()161 int ObexServerSession::SendSrmResponse()
162 {
163     OBEX_LOG_DEBUG("Call %{public}s", __PRETTY_FUNCTION__);
164     if (invalid_) {
165         return -1;
166     }
167     if (!isSupportSrm_) {
168         return -1;
169     }
170     if (!sendObject_) {
171         return -1;
172     }
173     if (!sendObject_->IsSrmEnable() || sendObject_->IsSrmWait()) {
174         return -1;
175     }
176     OBEX_LOG_DEBUG("SendSrmResponse: Server Start send with SRM MODE START");
177     return ProcessSendSrmResponse();
178 }
179 
Invalid()180 void ObexServerSession::Invalid()
181 {
182     invalid_ = true;
183     receivedObject_ = nullptr;
184     sendObject_ = nullptr;
185 }
186 
ObexSetPathObject(const std::vector<std::u16string> & paths)187 ObexSetPathObject::ObexSetPathObject(const std::vector<std::u16string> &paths)
188     : paths_(paths), pos_(0)
189 {}
190 
GetNextPath()191 std::u16string ObexSetPathObject::GetNextPath()
192 {
193     if (pos_ >= paths_.size()) {
194         return nullptr;
195     }
196     return paths_.at(pos_++);
197 }
198 
IsDone() const199 bool ObexSetPathObject::IsDone() const
200 {
201     return pos_ >= paths_.size();
202 }
203 
204 // ObexClientSendObject
ObexClientSendObject(const ObexHeader & firstReq,std::shared_ptr<ObexBodyObject> bodyReader,uint16_t mtu)205 ObexClientSendObject::ObexClientSendObject(
206     const ObexHeader &firstReq, std::shared_ptr<ObexBodyObject> bodyReader, uint16_t mtu)
207     : reqIndex_(0), srmEnable_(false), isDone_(false), mtu_(mtu),
208       firstReq_(std::make_unique<ObexHeader>(firstReq)),
209       bodyReader_(bodyReader)
210 {}
211 
SetBodyToHeader(ObexHeader & header,const uint16_t & remainLength)212 bool ObexClientSendObject::SetBodyToHeader(ObexHeader &header, const uint16_t &remainLength)
213 {
214     auto buf = std::make_unique<uint8_t[]>(remainLength);
215     int cnt = bodyReader_->Read(buf.get(), remainLength);
216     if (cnt < 0) {
217         return false;
218     }
219     if (cnt < remainLength) {
220         isDone_ = true;
221     }
222     if (isDone_) {
223         OBEX_LOG_DEBUG("GetNextReqHeader Add End-Body count %{public}d", cnt);
224         header.SetFinalBit(true);
225         header.AppendItemEndBody(buf.get(), cnt);
226     } else {
227         OBEX_LOG_DEBUG("GetNextReqHeader Add Body count %{public}d", cnt);
228         header.SetFinalBit(false);
229         header.AppendItemBody(buf.get(), cnt);
230     }
231     return true;
232 }
233 
GetNextReqHeader(bool useSrm)234 std::unique_ptr<ObexHeader> ObexClientSendObject::GetNextReqHeader(bool useSrm)
235 {
236     OBEX_LOG_DEBUG("Call %{public}s", __PRETTY_FUNCTION__);
237     if (isDone_) {
238         return nullptr;
239     }
240     std::unique_ptr<ObexHeader> header = nullptr;
241     if (reqIndex_ == 0) {
242         header = std::make_unique<ObexHeader>(*firstReq_);
243     } else {
244         header = std::make_unique<ObexHeader>(*firstReq_, true);
245         auto connectId = firstReq_->GetItemConnectionId();
246         if (connectId != nullptr) {
247             header->AppendItemConnectionId(connectId->GetWord());
248         }
249     }
250     if (useSrm) {
251         if (!header->HasHeader(ObexHeader::SRM)) {
252             header->AppendItemSrm(useSrm);
253         }
254     }
255     uint16_t pktLen = header->GetFieldPacketLength();
256     if (reqIndex_ == 0 && pktLen == mtu_ - ObexHeader::MIN_PACKET_LENGTH) {
257         reqIndex_++;
258         return header;
259     }
260     if (pktLen > mtu_) {
261         OBEX_LOG_ERROR("ObexClientSendObject:pktLen[%{public}d] can't large then mtu_[%{public}d]", pktLen, mtu_);
262         return nullptr;
263     }
264 
265     if ((reqIndex_ != 0) && (pktLen >= mtu_ - ObexHeader::MIN_PACKET_LENGTH)) {
266         OBEX_LOG_ERROR("ObexClientSendObject:can't send next packet, reqIndex_[%{public}d]!=0 && "
267             "pktLen[%{public}d]>=mtu_[%{public}d] - 3", reqIndex_, int(pktLen), int(mtu_));
268         return nullptr;
269     }
270     uint16_t remainLength = mtu_ - pktLen - ObexHeader::HDR_BYTES_PREFIX_LENGTH;  // 3: body header+len
271     if (!SetBodyToHeader(*header, remainLength)) {
272         return nullptr;
273     }
274     reqIndex_++;
275     return header;
276 }
277 
IsDone() const278 bool ObexClientSendObject::IsDone() const
279 {
280     return isDone_;
281 }
282 
SetSrmEnable(bool srmEnable)283 void ObexClientSendObject::SetSrmEnable(bool srmEnable)
284 {
285     srmEnable_ = srmEnable;
286 }
287 
IsSrmEnable() const288 bool ObexClientSendObject::IsSrmEnable() const
289 {
290     return srmEnable_;
291 }
292 
SetSrmWait(bool wait)293 void ObexClientSendObject::SetSrmWait(bool wait)
294 {
295     srmWait_ = wait;
296 }
297 
IsSrmWait() const298 bool ObexClientSendObject::IsSrmWait() const
299 {
300     return srmWait_;
301 }
302 
SetSrmSending()303 void ObexClientSendObject::SetSrmSending()
304 {
305     isSrmSending_ = true;
306 }
307 
IsSrmSending() const308 bool ObexClientSendObject::IsSrmSending() const
309 {
310     return isDone_ ? false : isSrmSending_;
311 }
312 
SetBusy(bool isBusy)313 void ObexClientSendObject::SetBusy(bool isBusy)
314 {
315     isBusy_ = isBusy;
316 }
317 
IsBusy() const318 bool ObexClientSendObject::IsBusy() const
319 {
320     return isBusy_;
321 }
322 
323 // ObexClientReceivedObject
ObexClientReceivedObject(const ObexHeader & firstReq,std::shared_ptr<ObexBodyObject> writer,bool supportSrm,int srmpCount)324 ObexClientReceivedObject::ObexClientReceivedObject(
325     const ObexHeader &firstReq, std::shared_ptr<ObexBodyObject> writer, bool supportSrm, int srmpCount)
326     : firstReq_(std::make_unique<ObexHeader>(firstReq)), bodyWriter_(writer)
327 {
328     supportSrmMode_ = supportSrm;
329     srmpCount_ = srmpCount;
330     srmEnable_ = false;
331     isDone_ = false;
332     if (supportSrmMode_) {
333         if (!firstReq_->HasHeader(ObexHeader::SRM)) {
334             firstReq_->AppendItemSrm(supportSrmMode_);
335         }
336         if (srmpCount_ < 1) {
337             firstReq_->RemoveItem(ObexHeader::SRMP);
338         } else {
339             firstReq_->AppendItemSrmp();
340             srmpCount_--;
341             srmpSended_ = true;
342         }
343     } else {
344         firstReq_->RemoveItem(ObexHeader::SRM);
345         firstReq_->RemoveItem(ObexHeader::SRMP);
346     }
347 }
348 
GetFirstReqHeader() const349 ObexHeader &ObexClientReceivedObject::GetFirstReqHeader() const
350 {
351     OBEX_LOG_DEBUG("Call %{public}s", __PRETTY_FUNCTION__);
352     return *firstReq_;
353 }
354 
GetFirstRespHeader() const355 const ObexHeader *ObexClientReceivedObject::GetFirstRespHeader() const
356 {
357     if (firstResp_) {
358         return firstResp_.get();
359     }
360     return nullptr;
361 }
362 
CacheResp(const ObexHeader & resp)363 void ObexClientReceivedObject::CacheResp(const ObexHeader &resp)
364 {
365     if (!firstResp_) {
366         firstResp_ = std::make_unique<ObexHeader>(resp);
367         firstResp_->RemoveItem(ObexHeader::SRM);
368         firstResp_->RemoveItem(ObexHeader::SRMP);
369         firstResp_->RemoveItem(ObexHeader::BODY);
370         firstResp_->SetExtendBodyObject(nullptr);
371     }
372 }
373 
GetContinueReqHeader()374 std::unique_ptr<ObexHeader> ObexClientReceivedObject::GetContinueReqHeader()
375 {
376     OBEX_LOG_DEBUG("Call %{public}s", __PRETTY_FUNCTION__);
377     auto header = std::make_unique<ObexHeader>(*firstReq_, true);
378     auto connectId = firstReq_->GetItemConnectionId();
379     if (connectId != nullptr) {
380         header->AppendItemConnectionId(connectId->GetWord());
381     }
382     if (srmpCount_ > 0) {
383         header->AppendItemSrmp();
384         srmpCount_--;
385         srmpSended_ = true;
386     } else {
387         srmpSended_ = false;
388     }
389     header->SetFinalBit(true);
390     return header;
391 }
392 
GetBodyWriter()393 std::shared_ptr<ObexBodyObject> &ObexClientReceivedObject::GetBodyWriter()
394 {
395     return bodyWriter_;
396 }
397 
AppendBody(const uint8_t * body,const uint16_t bodyLen)398 void ObexClientReceivedObject::AppendBody(const uint8_t *body, const uint16_t bodyLen)
399 {
400     bodyWriter_->Write(body, bodyLen);
401     receivedSize_ += bodyLen;
402     OBEX_LOG_DEBUG("ObexClientReceivedObject:ReceivedSize + %{public}d = %zu", bodyLen, receivedSize_);
403 }
404 
IsDone() const405 bool ObexClientReceivedObject::IsDone() const
406 {
407     return isDone_;
408 }
409 
SetDone(bool done)410 void ObexClientReceivedObject::SetDone(bool done)
411 {
412     isDone_ = done;
413 }
414 
SetSrmEnable(bool srmEnable)415 void ObexClientReceivedObject::SetSrmEnable(bool srmEnable)
416 {
417     srmEnable_ = srmEnable;
418 }
419 
IsSrmEnable() const420 bool ObexClientReceivedObject::IsSrmEnable() const
421 {
422     return srmEnable_;
423 }
424 
SetSrmWait(bool wait)425 void ObexClientReceivedObject::SetSrmWait(bool wait)
426 {
427     srmWait_ = wait;
428 }
429 
IsSrmWait() const430 bool ObexClientReceivedObject::IsSrmWait() const
431 {
432     return srmWait_;
433 }
434 
IsSupportSrmMode() const435 bool ObexClientReceivedObject::IsSupportSrmMode() const
436 {
437     return supportSrmMode_;
438 }
439 
IsSendNextReq() const440 bool ObexClientReceivedObject::IsSendNextReq() const
441 {
442     if (IsSrmEnable() && !IsSrmWait() && !srmpSended_) {
443         return false;
444     }
445     return true;
446 }
447 
448 // ObexServerReceivedObject
ObexServerReceivedObject(const ObexHeader & firstReq,std::shared_ptr<ObexBodyObject> writer)449 ObexServerReceivedObject::ObexServerReceivedObject(const ObexHeader &firstReq, std::shared_ptr<ObexBodyObject> writer)
450     : baseReq_(std::make_unique<ObexHeader>(firstReq))
451 {
452     baseReq_->RemoveItem(ObexHeader::SRM);
453     baseReq_->RemoveItem(ObexHeader::SRMP);
454     baseReq_->RemoveItem(ObexHeader::BODY);
455     baseReq_->SetExtendBodyObject(nullptr);
456     baseReq_->SetFinalBit(true);
457     writer_ = writer;
458 }
459 
AppendBody(const uint8_t * body,const uint16_t bodyLen)460 void ObexServerReceivedObject::AppendBody(const uint8_t *body, const uint16_t bodyLen)
461 {
462     writer_->Write(body, bodyLen);
463     receivedSize_ += bodyLen;
464     OBEX_LOG_DEBUG("ObexServerReceivedObject:ReceivedSize + %{public}d = %zu", bodyLen, receivedSize_);
465 }
466 
GetWriter()467 std::shared_ptr<ObexBodyObject> &ObexServerReceivedObject::GetWriter()
468 {
469     return writer_;
470 }
471 
CreateReceivedHeader()472 std::unique_ptr<ObexHeader> ObexServerReceivedObject::CreateReceivedHeader()
473 {
474     auto header = std::make_unique<ObexHeader>(*baseReq_);
475     header->SetExtendBodyObject(writer_);
476     return header;
477 }
478 
SetSrmEnable(bool srmEnable)479 void ObexServerReceivedObject::SetSrmEnable(bool srmEnable)
480 {
481     srmEnable_ = srmEnable;
482 }
483 
IsSrmEnable() const484 bool ObexServerReceivedObject::IsSrmEnable() const
485 {
486     return srmEnable_;
487 }
488 
SetSrmWait(bool wait)489 void ObexServerReceivedObject::SetSrmWait(bool wait)
490 {
491     srmWait_ = wait;
492 }
493 
IsSrmWait() const494 bool ObexServerReceivedObject::IsSrmWait() const
495 {
496     return srmWait_;
497 }
498 
SetSrmReceiving()499 void ObexServerReceivedObject::SetSrmReceiving()
500 {
501     isSrmReceiving_ = true;
502 }
503 
IsSrmReceiving() const504 bool ObexServerReceivedObject::IsSrmReceiving() const
505 {
506     return isSrmReceiving_;
507 }
508 
ObexServerSendObject(const ObexHeader & firstReq,const ObexHeader & firstResp,std::shared_ptr<ObexBodyObject> bodyReader,uint16_t mtu,bool supportSrm)509 ObexServerSendObject::ObexServerSendObject(const ObexHeader &firstReq, const ObexHeader &firstResp,
510     std::shared_ptr<ObexBodyObject> bodyReader, uint16_t mtu, bool supportSrm)
511     : firstReq_(std::make_unique<ObexHeader>(firstReq)), firstResp_(std::make_unique<ObexHeader>(firstResp))
512 {
513     firstResp_->RemoveItem(ObexHeader::SRM);
514     firstResp_->RemoveItem(ObexHeader::SRMP);
515     bodyReader_ = bodyReader;
516     mtu_ = mtu;
517     reqIndex_ = 0;
518     srmEnable_ = false;
519     isDone_ = false;
520     supportSrmMode_ = supportSrm;
521 }
522 
SetSrmParam(ObexHeader & header)523 void ObexServerSendObject::SetSrmParam(ObexHeader &header)
524 {
525     if (supportSrmMode_) {
526         if (reqIndex_ == 0 && firstReq_->HasHeader(ObexHeader::SRM)) {
527             OBEX_LOG_DEBUG("ObexServerSendObject send response with SRM set to true");
528             SetSrmEnable(firstReq_->GetItemSrm());
529             if (IsSrmEnable()) {
530                 header.AppendItemSrm(true);
531             }
532         }
533         if (reqIndex_ == 0 && firstReq_->HasHeader(ObexHeader::SRMP)) {
534             OBEX_LOG_DEBUG("ObexServerSendObject srmp_wait Set to true");
535             SetSrmWait(firstReq_->GetItemSrmp());
536         }
537     }
538 }
539 
SetBodyToHeader(ObexHeader & header,const uint16_t & remainLength)540 bool ObexServerSendObject::SetBodyToHeader(ObexHeader &header, const uint16_t &remainLength)
541 {
542     auto buf = std::make_unique<uint8_t[]>(remainLength);
543     int cnt = bodyReader_->Read(buf.get(), remainLength);
544     if (cnt < 0) {
545         return false;
546     }
547     if (cnt < remainLength) {
548         isDone_ = true;
549     }
550     if (isDone_) {
551         OBEX_LOG_DEBUG("GetNextRespHeader Add End-Body count %{public}d", cnt);
552         header.SetRespCode(static_cast<uint8_t>(ObexRspCode::SUCCESS));
553         header.AppendItemEndBody(buf.get(), cnt);
554     } else {
555         OBEX_LOG_DEBUG("GetNextRespHeader Add Body count %{public}d", cnt);
556         header.SetRespCode(static_cast<uint8_t>(ObexRspCode::CONTINUE));
557         header.AppendItemBody(buf.get(), cnt);
558     }
559     return true;
560 }
561 
GetNextRespHeader()562 std::unique_ptr<ObexHeader> ObexServerSendObject::GetNextRespHeader()
563 {
564     if (isDone_) {
565         return nullptr;
566     }
567     std::unique_ptr<ObexHeader> header = nullptr;
568     if (reqIndex_ == 0) {
569         header = std::make_unique<ObexHeader>(*firstResp_);
570     } else {
571         header = std::make_unique<ObexHeader>(*firstResp_, true);
572     }
573     // Set SRM
574     SetSrmParam(*header);
575 
576     uint16_t pktLen = header->GetFieldPacketLength();
577     if (reqIndex_ == 0 && pktLen == mtu_ - ObexHeader::MIN_PACKET_LENGTH) {
578         reqIndex_++;
579         return header;
580     }
581     if (pktLen > mtu_) {
582         OBEX_LOG_ERROR("ObexServerSendObject:pktLen[%{public}d] can't large then mtu[%{public}d]", pktLen, mtu_);
583         return nullptr;
584     }
585 
586     if (reqIndex_ != 0 && pktLen >= mtu_ - ObexHeader::MIN_PACKET_LENGTH) {
587         OBEX_LOG_ERROR("ObexServerSendObject:can't send next packet, reqIndex[%{public}d] != 0 && "
588             "pktLen[%{public}d] >= mtu[%{public}d] - 3", reqIndex_, pktLen, mtu_);
589         return nullptr;
590     }
591     if (!startBodyResp_) {
592         header->SetRespCode(static_cast<uint8_t>(ObexRspCode::CONTINUE));
593     } else {
594         uint16_t remainLength = mtu_ - pktLen - ObexHeader::HDR_BYTES_PREFIX_LENGTH;  // 3: body header+len
595         if (!SetBodyToHeader(*header, remainLength)) {
596             return nullptr;
597         }
598     }
599     reqIndex_++;
600     return header;
601 }
602 
IsDone() const603 bool ObexServerSendObject::IsDone() const
604 {
605     return isDone_;
606 }
607 
SetSrmEnable(bool srmEnable)608 void ObexServerSendObject::SetSrmEnable(bool srmEnable)
609 {
610     srmEnable_ = srmEnable;
611 }
612 
IsSrmEnable() const613 bool ObexServerSendObject::IsSrmEnable() const
614 {
615     return srmEnable_;
616 }
617 
SetSrmWait(bool wait)618 void ObexServerSendObject::SetSrmWait(bool wait)
619 {
620     srmWait_ = wait;
621 }
622 
IsSrmWait() const623 bool ObexServerSendObject::IsSrmWait() const
624 {
625     return srmWait_;
626 }
627 
SetStartBodyResp(bool start)628 void ObexServerSendObject::SetStartBodyResp(bool start)
629 {
630     startBodyResp_ = start;
631 }
632 
SetSrmSending()633 void ObexServerSendObject::SetSrmSending()
634 {
635     isSrmSending_ = true;
636 }
637 
IsSrmSending() const638 bool ObexServerSendObject::IsSrmSending() const
639 {
640     return isDone_ ? false : isSrmSending_;
641 }
642 
SetBusy(bool isBusy)643 void ObexServerSendObject::SetBusy(bool isBusy)
644 {
645     isBusy_ = isBusy;
646 }
647 
IsBusy() const648 bool ObexServerSendObject::IsBusy() const
649 {
650     return isBusy_;
651 }
652 
IsSupportSrmMode() const653 bool ObexServerSendObject::IsSupportSrmMode() const
654 {
655     return supportSrmMode_;
656 }
657 
ObexSession(const RawAddress & remoteAddr)658 ObexSession::ObexSession(const RawAddress &remoteAddr) : remoteAddr_(remoteAddr)
659 {}
660 
ObexClientSession(const RawAddress & remoteAddr)661 ObexClientSession::ObexClientSession(const RawAddress &remoteAddr) : ObexSession(remoteAddr)
662 {}
663 }  // namespace bluetooth
664 }  // namespace OHOS