【図解】Ethernetフレームの構造

悩んでいる人

Ethernetフレームを自前で実装する必要があるため、Ethernetフレームの構造を実装例とともに解説して欲しい。

こんなお悩みを解決します。

今回は、Ethernetフレームの構造を解説し、同時に実装例を紹介します。

現在では、宛先、ポート、送信するデータを用意して関数を呼び出せば、Ethernetフレームの構造を知らなくても通信ができます。

実際、通信する際は、通信プロトコルに合わせて様々なヘッダーが付与されるのですが、このヘッダー付与は、kernelが担っています。

一方、kernelが担っている部分に変更を加える場合は、途端に対応が困難になります。

そこで、Ethernetフレームの構造を理解し、自前で構築することで、問題を解決したいと思います。

Ethernetフレームの構造

Ethernetフレームは、以下のような構造になります。

上記に登場するMACアドレスについて説明します。

MACアドレスとは、Ethernet通信において使用される物理アドレスのことを指します。

PCには、LANケーブルを差し込む部分があると思いますが、その物理的なポートに割り当てられた固有のIDとなります。

また、上記のうち、オレンジ色のフィールドは、Ethernetヘッダと呼ばれ、以下のような内訳となります。

タイプで設定できる情報は決まっており、主なものとして以下が利用されます。

ここで、0xで始まる数値は、16進数であることを意味します。

以降では、IPv4を対象に、TCP/UDPについて解説をします。

IPヘッダの構造

IPv4で通信する際は、Ethernetフレームのデータ部分にIPヘッダというものが付与されます。

この時、Ethernetフレームの構造をさらに細かく見ると以下のようになります。

このIPヘッダは、以下のような構造になっています。

各フィールドの内訳は、以下のようになります。

今回、チェックサムを計算するため、以下のような補助関数を定義しています。（非公開関数としてutils.cにて定義）

この関数の出力結果をビット反転したものがチェックサムの値となります。

#define CHECKSUM_MSB (0x80000000)
#define CHECKSUM_MASK (0x0000FFFF)
#define SHIFT_CHECKSUM(x) (((x) & (uint32_t)CHECKSUM_MASK) + (((x) >> 16) & (uint32_t)CHECKSUM_MASK))

uint16_t calcTotal(const uint8_t *data, int32_t size, uint16_t initValue) {
    register uint32_t sum;
    register const uint16_t *ptr;
    register int32_t idx;
    uint16_t val;

    sum = (uint32_t)initValue & (uint32_t)CHECKSUM_MASK;
    ptr = (const uint16_t *)data;

    for (idx = size; idx > 1; idx -= 2) {
        sum += (*ptr);
        // check overflow
        if (sum & (uint32_t)CHECKSUM_MSB) {
            sum = SHIFT_CHECKSUM(sum);
        }
        ptr++;
    }
    if (1 == idx) {
        val = 0;
        memcpy(&val, ptr, sizeof(uint8_t));
        sum += (uint32_t)(val & (uint16_t)0x00FF);
    }
    while (sum >> 16) {
        sum = SHIFT_CHECKSUM(sum);
    }

    return (uint16_t)(sum & (uint32_t)CHECKSUM_MASK);
}

IPヘッダの場合、以下のような実装をしています。

ip.check = 0;
ip.check = ~calcTotal((const uint8_t *)&ip, (int32_t)ipHeaderSize, 0);

また、フラグのビット0～ビット2は、以下のように対応します。

UDPヘッダの構造

UDPで通信する場合、IPヘッダのデータ部分にUDPヘッダというものが付与されます。

この時、Ethernetフレームの構造をさらに細かく見ると以下のようになります。

このUDPヘッダは、以下のような構造になっています。

各フィールドの内訳は、以下のようになります。

UDPヘッダの場合、下記のような疑似ヘッダを付与して、チェックサムを計算します。

今回は、上記の疑似ヘッダを利用して、UDPの疑似ヘッダを以下のように計算しています。

IPヘッダで定義した補助関数を利用しています。

static uint16_t calcChksum(const uint8_t *header, const uint8_t *data, size_t headerSize, uint16_t dataLength) {
    register uint16_t sum;

    // calculate header
    sum = calcTotal(header, (int32_t)headerSize, 0);
    // calculate data
    sum = calcTotal(data, (int32_t)dataLength, sum);

    return (~sum);
}

利用する際は、下記のような構造体を定義し、上記の関数を呼び出します。

struct pseudo_header_t {
    uint32_t srcIPAddr;
    uint32_t dstIPAddr;
    uint8_t reserved;
    uint8_t protocol;
    uint16_t dataLength;
    uint16_t srcPort;
    uint16_t dstPort;
    uint16_t len;
    uint16_t checksum;
};

struct udp_header_arg_t {
    uint32_t srcIPAddr;
    uint32_t dstIPAddr;
    uint16_t srcPort;
    uint16_t dstPort;
    uint16_t dataLength;
    const uint8_t *data;
};

// 中略

ph.reserved = 0;
ph.checksum = 0;
// calculate checksum
udp.uh_sum = calcChksum((const uint8_t *)&ph, (const uint8_t *)(arg->data), sizeof(struct pseudo_header_t), arg->dataLength);

TCPヘッダの構造

UDPと同様に、TCPで通信する場合、IPヘッダのデータ部分にTCPヘッダというものが付与されます。

この時、Ethernetフレームの構造をさらに細かく見ると以下のようになります。

このTCPヘッダは、以下のような構造になっています。

各フィールドの内訳は、以下のようになります。

また、セッションフラグの内訳は以下のようになっております。

それぞれの内容を以下に示します。

TCPヘッダの場合、下記のような疑似ヘッダを付与して、チェックサムを計算します。

今回は、上記の疑似ヘッダを利用して、下記のような構造体と関数を定義し、TCPの疑似ヘッダを以下のように計算しています。

IPヘッダで定義した補助関数を利用しています。

struct pseudo_header_t {
    uint32_t srcIPAddr;
    uint32_t dstIPAddr;
    uint16_t protocol; // reserved(uint8_t) + protocol(uint8_t)
    uint16_t dataLength;
    uint16_t srcPort;
    uint16_t dstPort;
    uint32_t seqNum;
    uint32_t ackNum;
    uint8_t dataOffset;
    uint8_t flags;
    uint16_t windowSize;
    uint16_t checksum;
    uint16_t urgentPointer;
};

struct checksum_arg_t {
    struct pseudo_header_t pseudoHeader;
    uint16_t optionLength;
    uint16_t dataLength;
    const uint8_t *options;
    const uint8_t *data;
};

static uint16_t calcChksum(const struct checksum_arg_t *arg) {
    register uint16_t sum;

    // calculate header
    sum = calcTotal((const uint8_t *)&(arg->pseudoHeader), (int32_t)sizeof(struct pseudo_header_t), 0);
    // calculate options
    sum = calcTotal(arg->options, (int32_t)(arg->optionLength), sum);
    // calculate data
    sum = calcTotal(arg->data, (int32_t)(arg->dataLength), sum);

    return (~sum);
}

利用する際は、下記のようにして上記の関数を呼び出します。

chksumArg.pseudoHeader.checksum = 0;
// calculate checksum
tcp.check = calcChksum((const struct checksum_arg_t *)&chksumArg);

使い方

以降では、今回実装したプログラムの使い方を説明します。

また、実装結果は、以下に格納してあります。

https://github.com/yuruto-free/raw-ethernet-frame/tree/v1.0.0

Ethernetフレームの構築

まず、C言語のプログラムで、下記のヘッダーを読み込みます。

#include "rawEthernetFrame.h"
#include "packetStructure.h"

次に、Ethernetフレームを扱う変数を定義、領域を確保します。

ここで、struct REF_param_tは、rawEthernetFrame.hで定義されています。

そして、Ethernetフレームを構築するAPIであるREF_createRawFrame関数を呼び出します。

最後に、確保した領域を解放します。

int main(void) {
    int32_t ret;
    struct REF_param_t params;
    struct REF_rawFrame_t *frame = NULL;
    // 領域確保
    ret = REF_mallocRawFrame(&frame);
    if ((int32_t)REF_SUCCESS != ret) {
        // エラー処理
        // 省略
    }
    // パラメータの設定
    memset(&params, 0x00, sizeof(struct REF_param_t));
    // 具体的な設定内容は省略 
    // 
    // Ethernetフレームの構築
    ret = REF_createRawFrame((const struct REF_param_t *)&params, frame);
    if ((int32_t)REF_SUCCESS != ret) {
        // エラー処理
        // 省略
    }
    // 確保した領域の開放
    (void)REF_freeRawFrame(&frame);
}

Ethernetフレームの解析

Ethernetフレームの構築とほとんど同じ使い方となります。

差分としては、以下の2点があります。

• callback関数を定義する。
• REF_dumpRawFrame関数を呼び出す。

差分部分を抽出した例を以下に示します。

// callback関数の定義
static int32_t callback(uint8_t packetType, void *data) {
    struct ether_header_t *eth;
    struct ip_header_t *ip;
    struct udp_header_t *udp;
    struct tcp_header_t *tcp;

    switch (packetType) {
        case REF_ETHER_PACKET:
            eth = (struct ether_header_t *)data;
            // Ether headerに対する処理
            break;

        case REF_IP_PACKET:
            ip = (struct ip_header_t *)data;
            // IP headerに対する処理
            break;

        case REF_UDP_PACKET:
            udp = (struct udp_header_t *)data;
            // UDP headerに対する処理
            break;

        case REF_TCP_PACKET:
            tcp = (struct tcp_header_t *)data;
            // TCP headerに対する処理
            break;

        default:
            break;
    }

    return 0;
}

int main(void) {
    // 前処理：省略

    // Ethernetフレームの解析
    (void)REF_dumpRawFrame((const struct REF_rawFrame_t *)frame, callback);

     // 後処理：省略
}

Ethernetフレームの解析結果は、callback関数を通して通知されます。

上記のサンプルは、下記に格納しています。

https://github.com/yuruto-free/raw-ethernet-frame/blob/v1.0.0/src/main.c

まとめ

実装結果は、以下に格納してあります。

https://github.com/yuruto-free/raw-ethernet-frame/tree/v1.0.0

Ethernetフレームの構造

Ethernetフレームは、以下のような構造になっています。

データの部分は、IP、TCP/UPDなど扱うプロトコルに応じて変化します。

IPヘッダの構造

IPヘッダは、以下のような構造になっています。

UDPヘッダの構造

UDPヘッダは、以下のような構造になっています。

TCPヘッダの構造

TCPヘッダは、以下のような構造になっています。

また、セッションフラグの内訳は、以下のようになります。

使い方　|　Ethernetフレームの構築

まず、C言語のプログラムで、下記のヘッダーを読み込みます。

#include "rawEthernetFrame.h"
#include "packetStructure.h"

次に、Ethernetフレームを扱う変数を定義、領域を確保します。

ここで、struct REF_param_tは、rawEthernetFrame.hで定義されています。

そして、Ethernetフレームを構築するAPIであるREF_createRawFrame関数を呼び出します。

最後に、確保した領域を解放します。

int main(void) {
    int32_t ret;
    struct REF_param_t params;
    struct REF_rawFrame_t *frame = NULL;
    // 領域確保
    ret = REF_mallocRawFrame(&frame);
    if ((int32_t)REF_SUCCESS != ret) {
        // エラー処理
        // 省略
    }
    // パラメータの設定
    memset(&params, 0x00, sizeof(struct REF_param_t));
    // 具体的な設定内容は省略 
    // 
    // Ethernetフレームの構築
    ret = REF_createRawFrame((const struct REF_param_t *)&params, frame);
    if ((int32_t)REF_SUCCESS != ret) {
        // エラー処理
        // 省略
    }
    // 確保した領域の開放
    (void)REF_freeRawFrame(&frame);
}

使い方　|　Ethernetフレームの解析

Ethernetフレームの構築とほとんど同じ使い方となります。

差分としては、以下の2点があります。

• callback関数を定義する。
• REF_dumpRawFrame関数を呼び出す。

差分部分を抽出した例を以下に示します。

// callback関数の定義
static int32_t callback(uint8_t packetType, void *data) {
    struct ether_header_t *eth;
    struct ip_header_t *ip;
    struct udp_header_t *udp;
    struct tcp_header_t *tcp;

    switch (packetType) {
        case REF_ETHER_PACKET:
            eth = (struct ether_header_t *)data;
            // Ether headerに対する処理
            break;

        case REF_IP_PACKET:
            ip = (struct ip_header_t *)data;
            // IP headerに対する処理
            break;

        case REF_UDP_PACKET:
            udp = (struct udp_header_t *)data;
            // UDP headerに対する処理
            break;

        case REF_TCP_PACKET:
            tcp = (struct tcp_header_t *)data;
            // TCP headerに対する処理
            break;

        default:
            break;
    }

    return 0;
}

int main(void) {
    // 前処理：省略

    // Ethernetフレームの解析
    (void)REF_dumpRawFrame((const struct REF_rawFrame_t *)frame, callback);

     // 後処理：省略
}

Ethernetフレームの解析結果は、callback関数を通して通知されます。