用C语言实现一个BER编解码器，有输入输出的界面，能将SNMP报文编码为实际输出的字节流，并能将实际收到的字节流解码为SNMP报文。

实现一个BER编解码器需要掌握BER编解码的规则和格式。BER（Basic Encoding Rules）是ASN.1（Abstract Syntax Notation One）的一种编码方式，ASN.1是一种数据描述语言，用于描述数据结构和编码规则。ASN.1规定了数据结构和类型，而BER是其中一种编码规则。

以下是一个简单的BER编解码器的示例程序，使用C语言实现。该程序可以将SNMP报文编码为实际输出的字节流，并能将实际收到的字节流解码为SNMP报文。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义ASN.1数据类型
#define INTEGER 0x02
#define OCTET_STRING 0x04
#define NULL_TYPE 0x05
#define OBJECT_IDENTIFIER 0x06
#define SEQUENCE 0x30

// 编码整数类型
int encode_integer(unsigned char *buf, int value) {
    int len = 0;
    if (value >= -128 && value <= 127) {
        // 如果是一个字节的整数
        buf[len++] = INTEGER;
        buf[len++] = 1; // 整数的长度为1
        buf[len++] = value & 0xff;
    } else if (value >= -32768 && value <= 32767) {
        // 如果是两个字节的整数
        buf[len++] = INTEGER;
        buf[len++] = 2; // 整数的长度为2
        buf[len++] = (value >> 8) & 0xff;
        buf[len++] = value & 0xff;
    } else {
        // 如果是四个字节的整数
        buf[len++] = INTEGER;
        buf[len++] = 4; // 整数的长度为4
        buf[len++] = (value >> 24) & 0xff;
        buf[len++] = (value >> 16) & 0xff;
        buf[len++] = (value >> 8) & 0xff;
        buf[len++] = value & 0xff;
    }
    return len;
}

// 编码字符串类型
int encode_octet_string(unsigned char *buf, char *str, int len) {
    int i;
    buf[0] = OCTET_STRING;
    buf[1] = len;
    for (i = 0; i < len; i++) {
        buf[i+2] = str[i];
    }
    return len + 2;
}

// 编码NULL类型
int encode_null(unsigned char *buf) {
    buf[0] = NULL_TYPE;
    buf[1] = 0;
    return 2;
}

// 编码对象标识符类型
int encode_object_identifier(unsigned char *buf, int *oid, int len) {
    int i;
    buf[0] = OBJECT_IDENTIFIER;
    for (i = 0; i < len; i++) {
        if (i == 0) {
            buf[1] = oid[i] * 40;
        } else if (i == 1) {
            buf[1] = buf[1] + oid[i];
            buf[2] = 0;
        } else {
            int j;
            unsigned char tmp[5];
            int tmplen;
            int value = oid[i];
            for (j = 0; value > 0; j++) {
                tmp[j] = (value & 0x7f) | 0x80;
                value = value >> 7;
            }
            tmp[j-1] = tmp[j-1] & 0x7f;
            tmplen = j;
            for (j = 0; j < tmplen; j++) {
                buf[i+j+1] = tmp[tmplen-j-1];
            }
            buf[i+j+1] = 0;
        }
    }
    return len + 1;
}

// 编码SNMP报文（V2c版本）
int encode_snmp(unsigned char *buf, int version, char *community, int *oid, int oidlen, int type, void *value) {
    int len = 0;
    buf[len++] = SEQUENCE;
    len += encode_integer(buf+len, version);
    len += encode_octet_string(buf+len, community, strlen(community));
    buf[len++] = SEQUENCE;
    int pdulen = 0;
    pdulen += encode_integer(buf+len+pdulen, 0); // request id
    pdulen += encode_integer(buf+len+pdulen, 0); // error status
    pdulen += encode_integer(buf+len+pdulen, 0); // error index
    buf[len++] = SEQUENCE;
    pdulen += encode_object_identifier(buf+len+pdulen, oid, oidlen);
    switch (type) {
        case INTEGER:
            pdulen += encode_integer(buf+len+pdulen, *(int *)value);
            break;
        case OCTET_STRING:
            pdulen += encode_octet_string(buf+len+pdulen, (char *)value, strlen((char *)value));
            break;
        case NULL_TYPE:
            pdulen += encode_null(buf+len+pdulen);
            break;
        default:
            break;
    }
    buf[len++] = pdulen;
    len += pdulen;
    return len;
}

// 解码整数类型
int decode_integer(unsigned char *buf, int *value) {
    int len = 0;
    if (buf[len++] != INTEGER) {
        return -1;
    }
    int i;
    int neg = 0;
    if (buf[len] & 0x80) {
        neg = 1;
        for (i = 0; i < 4; i++) {
            value[i] = 0xff;
        }
    } else {
        for (i = 0; i < 4; i++) {
            value[i] = 0;
        }
    }
    int n = buf[len++];
    for (i = 0; i < n; i++) {
        if (neg) {
            value[3-i] = buf[len+i] ^ 0xff;
        } else {
            value[3-i] = buf[len+i];
        }
    }
    len += n;
    return len;
}

// 解码字符串类型
int decode_octet_string(unsigned char *buf, char *str, int *len) {
    int i;
    if (buf[0] != OCTET_STRING) {
        return -1;
    }
    *len = buf[1];
    for (i = 0; i < *len; i++) {
        str[i] = buf[i+2];
    }
    return *len + 2;
}

// 解码NULL类型
int decode_null(unsigned char *buf) {
    if (buf[0] != NULL_TYPE) {
        return -1;
    }
    return 2;
}

// 解码对象标识符类型
int decode_object_identifier(unsigned char *buf, int *oid, int *len) {
    int i = 0;
    if (buf[i++] != OBJECT_IDENTIFIER) {
        return -1;
    }
    oid[0] = buf[i] / 40;
    oid[1] = buf[i] % 40;
    i++;
    int j = 2;
    while (buf[i] != 0) {
        int value = 0;
        while (buf[i] & 0x80) {
            value = (value << 7) | (buf[i] & 0x7f);
            i++;
        }
        value = (value << 7) | buf[i];
        oid[j++] = value;
        i++;
    }
    *len = j;
    return i+1;
}

// 解码SNMP报文
int decode_snmp(unsigned char *buf, int buflen, int *version, char *community, int *oid, int *oidlen, int *type, void *value) {
    int len = 0;
    if (buf[len++] != SEQUENCE) {
        return -1;
    }
    len += decode_integer(buf+len, version);
    len += decode_octet_string(buf+len, community, &len);
    if (buf[len++] != SEQUENCE) {
        return -1;
    }
    len += decode_integer(buf+len, &len); // request id
    len += decode_integer(buf+len, &len); // error status
    len += decode_integer(buf+len, &len); // error index
    if (buf[len++] != SEQUENCE) {
        return -1;
    }
    len += decode_object_identifier(buf+len, oid, oidlen);
    switch (buf[len++]) {
        case INTEGER:
            *type = INTEGER;
            len += decode_integer(buf+len, (int *)value);
            break;
        case OCTET_STRING:
            *type = OCTET_STRING;
            len += decode_octet_string(buf+len, (char *)value, &len);
            break;
        case NULL_TYPE:
            *type = NULL_TYPE;
            len += decode_null(buf+len);
            break;
        default:
            break;
    }
    return len;
}

int main() {
    // 编码SNMP报文
    unsigned char buf[1024];
    int len = encode_snmp(buf, 1, "public", (int[]){1, 3, 6, 1, 2, 1, 1, 1, 0}, 9, OCTET_STRING, "test");
    printf("Encoded SNMP message length: %d\n", len);
    for (int i = 0; i < len; i++) {
        printf("%02x ", buf[i]);
    }
    printf("\n");

    // 解码SNMP报文
    int version;
    char community[64];
    int oid[64];
    int oidlen;
    int type;
    void *value;
    int decoded_len = decode_snmp(buf, len, &version, community, oid, &oidlen, &type, value);
    printf("Decoded SNMP message length: %d\n", decoded_len);
    printf("Version: %d\n", version);
    printf("Community: %s\n", community);
    printf("OID: %d.%d.%d.%d.%d.%d.%d.%d.%d\n", oid[0], oid[1], oid[2], oid[3], oid[4], oid[5], oid[6], oid[7], oid[8]);
    printf("Type: %d\n", type);
    printf("Value: %s\n", (char *)value);

    return 0;
}

在上面的示例程序中，我们定义了几个编码函数和解码函数，分别用于编码和解码不同类型的数据。然后，我们定义了一个函数`encode_snmp()`，用于编码SNMP报文。该函数接受一些参数，如版本号、社区、OID、类型和值等，然后根据ASN.1和BER规则将它们编码为字节流。最后，我们定义了一个函数`decode_snmp()`，用于解码SNMP报文。该函数将字节流解码为各个参数，并返回解码后的字节数。通过这两个函数，我们可以轻松地将SNMP报文编码为字节流，或者将字节流解码为SNMP报文。

需要注意的是，上述示例程序只是一个简单的实现，只能处理ASN.1和BER的一部分规则和数据类型。在实际应用中，需要根据具体的需求和协议规范来进行编码和解码。