mozquic/Ping.cpp at master · mcmanus/mozquic · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "Logging.h"
#include "MozQuic.h"
#include "MozQuicInternal.h"
#include "Streams.h"

#include <assert.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

namespace mozquic  {

uint32_t
MozQuic::CheckPeer(uint32_t deadline)
{
  if (mPingDeadline->Armed()) {
    return MOZQUIC_OK;
  }
  if ((mConnectionState != CLIENT_STATE_CONNECTED) &&
      (mConnectionState != SERVER_STATE_CONNECTED)) {
    ConnectionLog1("check peer not connected\n");
    return MOZQUIC_ERR_GENERAL;
  }

  mPingDeadline->Arm(deadline);

  assert(mMTU <= kMaxMTU);
  unsigned char plainPkt[kMaxMTU];
  uint32_t used = 0;

  unsigned char *pnPtr;
  CreateShortPacketHeader(plainPkt, mMTU - kTagLen, used, &pnPtr);
  uint32_t headerLen = used;
  plainPkt[used++] = FRAME_TYPE_PING;

  return ProtectedTransmit(plainPkt, headerLen,  pnPtr,
                           plainPkt + headerLen,
                           FRAME_TYPE_PING_LENGTH,
                           mMTU - headerLen - kTagLen, true, true);
}

void
MozQuic::StartPMTUD1()
{
  if (mPMTUD1PacketNumber) {
    return;
  }
  if ((mConnectionState != CLIENT_STATE_CONNECTED) &&
      (mConnectionState != SERVER_STATE_CONNECTED)) {
    return;
  }

  if (mMTU >= kMaxMTU) {
    return;
  }
  if (mMTU >= mMaxPacketConfig) {
    return;
  }
  unsigned char plainPkt[kMaxMTU];
  mPMTUDTarget = (kMaxMTU < mMaxPacketConfig) ? kMaxMTU : mMaxPacketConfig;

  uint32_t headerLen;
  unsigned char *pnPtr;
  CreateShortPacketHeader(plainPkt, mPMTUDTarget - kTagLen, headerLen, &pnPtr);
  uint32_t padAmt = mPMTUDTarget - headerLen - kTagLen;
  memset(plainPkt + headerLen, FRAME_TYPE_PADDING, padAmt);
  plainPkt[headerLen] = FRAME_TYPE_PING; // make the first frame a ping frame

  ConnectionLog5("pmtud1: %d MTU test started\n", mPMTUDTarget);
  mPMTUD1PacketNumber = mNextTransmitPacketNumber;
  mPMTUD1Deadline->Arm(3000); // 3 seconds to ack the ping

  uint32_t bytesOut = 0;
  if (ProtectedTransmit(plainPkt, headerLen, pnPtr,
                        plainPkt + headerLen, padAmt, kMaxMTU,
                        false, true, false,
                        mPMTUDTarget, &bytesOut) != MOZQUIC_OK) {
    mPMTUD1PacketNumber = 0;
  } else {
    mStreamState->TrackPacket(mPMTUD1PacketNumber, bytesOut);
  }
}

void
MozQuic::CompletePMTUD1()
{
  assert (mPMTUD1PacketNumber);
  ConnectionLog5("pmtud1: %d MTU CONFIRMED.\n", mPMTUDTarget);
  mPMTUD1Deadline->Cancel();
  mMTU = mPMTUDTarget;
}

void
MozQuic::AbortPMTUD1()
{
  assert (mPMTUD1PacketNumber);
  ConnectionLog1("pmtud1: %d MTU CHECK Failed.\n", mPMTUDTarget);
  mPMTUD1PacketNumber = 0;
  mPMTUD1Deadline->Cancel();
}

}