matter/libmp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

new: finishing up base mptp functions

Browse Source
This commit is contained in:
ngn 2024-06-22 04:18:00 +03:00
parent cb66106e50
commit 19c98b763d
8 changed files with 322 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
examples/Makefile
View File

@ -1,7 +1,11 @@
CC = gcc CC = gcc
all: ../dist/example_pool all: ../dist/example_pool ../dist/example_server
../dist/example_pool: pool/*.c ../dist/libmp.so ../dist/example_pool: pool/*.c ../dist/libmp.so
mkdir -pv ../dist mkdir -pv ../dist
$(CC) -L../dist $< -lmp -o $@ $(CC) -L../dist $< -lmp -o $@
../dist/example_server: server/*.c ../dist/libmp.so
mkdir -pv ../dist
$(CC) -L../dist $< -lmp -o $@

52
examples/server/main.c Normal file
View File

@ -0,0 +1,52 @@
#include "../../include/error.h"
#include "../../include/mptp.h"
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
int main(int argc, char *argv[]) {
int ret = EXIT_FAILURE;
if (argc != 3) {
printf("usage: %s <host> <port>\n", argv[0]);
return ret;
}
int porti = atoi(argv[2]);
if (porti <= 0 || porti > UINT16_MAX) {
printf("bad port number\n");
return ret;
}
int sock = lm_mptp_server_listen(argv[1], porti);
if (sock < 0) {
printf("failed to start the server: %s\n", lm_strerror());
return ret;
}
lm_mptp_t packet;
struct sockaddr addr;
while (lm_mptp_server_recv(sock, &packet, &addr)) {
switch (MPTP_FLAGS_TYPE(&packet)) {
case MPTP_C2S_PING:
bzero(&packet, sizeof(packet));
lm_mptp_packet_init(&packet, false, MPTP_S2C_PONG, true);
lm_mptp_server_send(sock, &packet, &addr);
break;
default:
bzero(&packet, sizeof(packet));
lm_mptp_packet_init(&packet, false, MPTP_S2C_WHAT, true);
lm_mptp_server_send(sock, &packet, &addr);
break;
}
}
ret = EXIT_SUCCESS;
end:
lm_mptp_close(sock);
return ret;
}

4
include/error.h
View File

@ -21,9 +21,11 @@ typedef enum lm_error {
LM_ERR_MPTPConnectFail = 17, LM_ERR_MPTPConnectFail = 17,
LM_ERR_MPTPRecvFail = 18, LM_ERR_MPTPRecvFail = 18,
LM_ERR_MPTPSendFail = 19, LM_ERR_MPTPSendFail = 19,
LM_ERR_MPTPChunkFail = 29, LM_ERR_MPTPBadChunk = 29,
LM_ERR_MPTPSetsockopt = 30, LM_ERR_MPTPSetsockopt = 30,
LM_ERR_MPTPTimeout = 31, LM_ERR_MPTPTimeout = 31,
LM_ERR_MPTPBindFail = 32,
LM_ERR_ArgNULL = 33,
} lm_error_t; } lm_error_t;
typedef struct lm_error_desc { typedef struct lm_error_desc {

119
include/mptp.h
View File

@ -1,5 +1,6 @@
#pragma once #pragma once
#include "types.h" #include "types.h"
#include <netdb.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
@ -7,56 +8,60 @@
/* /*
0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
############### #####################################
# FLAGS # # FLAGS #
############### #####################################
# SIZE # # SIZE #
# # #####################################
############### # DATA #
# DATA # #...................................#
#.............#
[8 bits] FLAGS [16 bits] FLAGS
=========================================================
| 8 bits used for specifying the version
--------------------------------------------------------- ---------------------------------------------------------
4 bits used for specifying the version | 1 bit used to specify if this is a request or response
|
| 0- it's a request
| 1- it's a response
--------------------------------------------------------- ---------------------------------------------------------
1 bit used to specify if this is a request or response | 4 bits used for request/response codes
|
0- it's a request | We have 4 types of different requests
1- it's a response | 0- PING: checks if the server is avaliable
| 1- INFO: gets information about the pool(s) the server is hosting
| 2- LIST: requests the package list for certain pool
| 3- PULL: requests a certain package from a certain pool
|
| And 4 types of responses
| 0- PONG: response for the ping request
| 1- COOL: everything is fine, here's the data you requested
| 2- BRUH: cannot access to the data you requested, or version mismatch
| 3- WHAT: bad request
--------------------------------------------------------- ---------------------------------------------------------
2 bits used for request/response codes | 1 bit used to specify if this the last response
|
We have 4 types of different requests | 0- no stay connected, im not done responsing yet
1- PING: checks if the server is avaliable | 1- yes, im done, disconnect
2- INFO: gets information about the pool(s) the server is hosting |
3- LIST: requests the package list for certain pool | always 1 for the requests
4- PULL: requests a certain package from a certain pool
And 4 types of responses
1- PONG: response for the ping request
2- COOL: everything is fine, here's the data you requested
3- BRUH: cannot access to the data you requested, or version mismatch
4- WHAT: bad request
--------------------------------------------------------- ---------------------------------------------------------
1 bit used to specify if this the last request/response | 2 bits is reserved for future use
--------------------------------------------------------- ---------------------------------------------------------
0- no stay connected, im not done responsing/requesting yet
1- yes, im done, disconnect
---------------------------------------------------------
[16 bits] SIZE [16 bits] SIZE
=========================================================
| All bits used for specifying the DATA size, in bytes
--------------------------------------------------------- ---------------------------------------------------------
All bits used for specifying the DATA size, in bytes
---------------------------------------------------------
[...] DATA [...] DATA
--------------------------------------------------------- ---------------------------------------------------------
Plaintext data used for that specific request/response, | Plaintext data used for that specific request/response,
max value for SIZE is 65535, so this section may have | max value for SIZE is 65535, so this section may have
65535 bytes total | 65535 bytes total
--------------------------------------------------------- ---------------------------------------------------------
*/ */
@ -66,7 +71,7 @@
#define MPTP_VERSION_SUPPORTED 0 #define MPTP_VERSION_SUPPORTED 0
#define MPTP_VERSION_MAX 15 // 4 bits #define MPTP_VERSION_MAX 15 // 4 bits
#define MPTP_CODE_MAX 4 // 2 bits #define MPTP_CODE_MAX 4 // 2 bits
#define MPTP_CHUNK_MAX 4096 #define MPTP_CHUNK_MAX 256
#define MPTP_TIMEOUT 10 #define MPTP_TIMEOUT 10
#define MPTP_REQUEST 0 #define MPTP_REQUEST 0
@ -86,24 +91,34 @@ typedef enum lm_mptp_response {
MPTP_S2C_WHAT = 3, MPTP_S2C_WHAT = 3,
} lm_mptp_response_t; } lm_mptp_response_t;
typedef struct lm_mptp { typedef struct lm_mptp_header {
uint8_t flags; uint16_t flags;
uint16_t size; uint16_t size;
char *data; } lm_mptp_header_t;
typedef struct lm_mptp {
lm_mptp_header_t header;
char data[MPTP_CHUNK_MAX];
} lm_mptp_t; } lm_mptp_t;
bool lm_mptp_init(lm_mptp_t *packet, bool is_request, uint8_t code, bool is_last); #define MPTP_FLAGS_VERSION(m) ((m)->header.flags & 0xFF00) >> 8
#define MPTP_FLAGS_VERSION(m) ((m->flags >> 4) & 15) #define MPTP_FLAGS_REQUEST(m) ((m)->header.flags & 0x0080) >> 1
#define MPTP_FLAGS_IS_REQUEST(m) (((m->flags >> 3) & 1) == 0) #define MPTP_FLAGS_TYPE(m) ((m)->header.flags & 0x0070) >> 4
#define MPTP_FLAGS_TYPE(m) ((m->flags >> 1) & 3) #define MPTP_FLAGS_LAST(m) ((m)->header.flags & 0x0008) >> 3
#define MPTP_FLAGS_IS_LAST(m) ((m->flags & 1) == 1)
int lm_mptp_connect(lm_url_t *url); #define MPTP_IS_REQUEST(m) MPTP_FLAGS_REQUEST(m) == 0
#define MPTP_IS_LAST(m) MPTP_FLAGS_LAST(m) == 1
bool lm_mptp_recv(int sock, lm_mptp_t *packet); bool lm_mptp_packet_init(lm_mptp_t *packet, bool is_request, uint8_t code, bool is_last);
bool lm_mptp_recv_data(int sock, char *data, size_t size); int lm_mptp_socket(char *addr, uint16_t port, struct sockaddr *saddr);
void lm_mptp_close(int sock);
bool lm_mptp_send(int sock, lm_mptp_t *packet); int lm_mptp_client_connect(char *addr, uint16_t port);
bool lm_mptp_send_data(int sock, char *data, size_t size); bool lm_mptp_client_verify(int sock, lm_mptp_t *packet); // not implemented
bool lm_mptp_client_send(int sock, lm_mptp_t *packet);
bool lm_mptp_client_recv(int sock, lm_mptp_t *packet);
void lm_mptp_disconnect(int sock); int lm_mptp_server_listen(char *addr, uint16_t port);
bool lm_mptp_server_verify(int sock, lm_mptp_t *packet, struct sockaddr *addr); // not implemented
bool lm_mptp_server_recv(int sock, lm_mptp_t *packet, struct sockaddr *addr);
bool lm_mptp_server_send(int sock, lm_mptp_t *packet, struct sockaddr *adrr);

12
locale/tr/LC_MESSAGES/libmp.po
View File

@ -8,7 +8,7 @@ msgid ""
msgstr "" msgstr ""
"Project-Id-Version: PACKAGE VERSION\n" "Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n" "Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-21 04:42+0300\n" "POT-Creation-Date: 2024-06-22 04:17+0300\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n" "Language-Team: LANGUAGE <LL@li.org>\n"
@ -79,7 +79,7 @@ msgid "invalid MPTP URL"
msgstr "" msgstr ""
#: src/error.c:28 #: src/error.c:28
msgid "failed to resolve hostname for MPTP communication" msgid "failed to resolve hostname for MPTP connection"
msgstr "" msgstr ""
#: src/error.c:29 #: src/error.c:29
@ -110,3 +110,11 @@ msgstr ""
#: src/error.c:35 #: src/error.c:35
msgid "MPTP connection timed out" msgid "MPTP connection timed out"
msgstr "" msgstr ""
#: src/error.c:36
msgid "failed to bind MPTP socket"
msgstr ""
#: src/error.c:37
msgid "required argument is a NULL pointer"
msgstr ""

6
src/error.c
View File

@ -25,14 +25,16 @@ char *lm_strerror() {
{.code = LM_ERR_MPTPBadVersion, .desc = _("unsupported MPTP version") }, {.code = LM_ERR_MPTPBadVersion, .desc = _("unsupported MPTP version") },
{.code = LM_ERR_MPTPBadCode, .desc = _("invalid MPTP request/response code") }, {.code = LM_ERR_MPTPBadCode, .desc = _("invalid MPTP request/response code") },
{.code = LM_ERR_MPTPBadUrl, .desc = _("invalid MPTP URL") }, {.code = LM_ERR_MPTPBadUrl, .desc = _("invalid MPTP URL") },
{.code = LM_ERR_MPTPHostFail, .desc = _("failed to resolve hostname for MPTP communication") }, {.code = LM_ERR_MPTPHostFail, .desc = _("failed to resolve hostname for MPTP connection") },
{.code = LM_ERR_MPTPSocketFail, .desc = _("failed to create a MPTP socket") }, {.code = LM_ERR_MPTPSocketFail, .desc = _("failed to create a MPTP socket") },
{.code = LM_ERR_MPTPConnectFail, .desc = _("failed to connect to the MPTP host") }, {.code = LM_ERR_MPTPConnectFail, .desc = _("failed to connect to the MPTP host") },
{.code = LM_ERR_MPTPRecvFail, .desc = _("failed receive MPTP data from host") }, {.code = LM_ERR_MPTPRecvFail, .desc = _("failed receive MPTP data from host") },
{.code = LM_ERR_MPTPSendFail, .desc = _("failed send MPTP data to host") }, {.code = LM_ERR_MPTPSendFail, .desc = _("failed send MPTP data to host") },
{.code = LM_ERR_MPTPChunkFail, .desc = _("MPTP data chunk is too large") }, {.code = LM_ERR_MPTPBadChunk, .desc = _("MPTP data chunk is too large") },
{.code = LM_ERR_MPTPSetsockopt, .desc = _("failed to set MPTP socket options") }, {.code = LM_ERR_MPTPSetsockopt, .desc = _("failed to set MPTP socket options") },
{.code = LM_ERR_MPTPTimeout, .desc = _("MPTP connection timed out") }, {.code = LM_ERR_MPTPTimeout, .desc = _("MPTP connection timed out") },
{.code = LM_ERR_MPTPBindFail, .desc = _("failed to bind MPTP socket") },
{.code = LM_ERR_ArgNULL, .desc = _("required argument is a NULL pointer") },
}; };
for (int i = 0; i < sizeof(errors) / sizeof(lm_error_desc_t); i++) { for (int i = 0; i < sizeof(errors) / sizeof(lm_error_desc_t); i++) {

269
src/mptp.c
View File

@ -1,78 +1,113 @@
#include "../include/mptp.h" #include "../include/mptp.h"
#include "../include/error.h" #include "../include/error.h"
#include "../include/url.h" #include "../include/url.h"
#include <arpa/inet.h>
#include <errno.h> #include <errno.h>
#include <netdb.h> #include <netdb.h>
#include <netinet/in.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <strings.h> #include <strings.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <unistd.h> #include <unistd.h>
bool lm_mptp_init(lm_mptp_t *packet, bool is_request, uint8_t code, bool is_last) { bool lm_mptp_packet_init(lm_mptp_t *packet, bool is_request, uint8_t code, bool is_last) {
packet->data = NULL; packet->header.flags = 0;
packet->flags = 0; packet->header.size = 0;
packet->size = 0; bzero(packet->data, MPTP_CHUNK_MAX);
if (code > MPTP_CODE_MAX) { if (code > MPTP_CODE_MAX) {
lm_error_set(LM_ERR_MPTPBadCode); lm_error_set(LM_ERR_MPTPBadCode);
return false; return false;
} }
// X-X-X-X-0-0-0-0 packet->header.flags |= (MPTP_VERSION_SUPPORTED << 8);
packet->flags |= (MPTP_VERSION_SUPPORTED << 4);
// 0-0-0-0-X-0-0-0
if (is_request) if (is_request)
packet->flags |= (MPTP_REQUEST << 3); packet->header.flags |= (MPTP_REQUEST << 7);
else else
packet->flags |= (MPTP_RESPONSE << 3); packet->header.flags |= (MPTP_REQUEST << 7);
// 0-0-0-0-0-X-X-0 packet->header.flags |= (code << 4);
packet->flags |= (code << 1);
// 0-0-0-0-0-0-0-X if (is_last || is_request)
if (is_last) packet->header.flags |= (1 << 3);
packet->flags |= 1;
else else
packet->flags |= 0; packet->header.flags |= (0 << 3);
return true; return true;
} }
int lm_mptp_connect(lm_url_t *url) { int lm_mptp_socket(char *addr, uint16_t port, struct sockaddr *saddr) {
if (NULL == url || NULL == url->host) { if (NULL == addr || NULL == saddr) {
lm_error_set(LM_ERR_MPTPBadUrl); lm_error_set(LM_ERR_ArgNULL);
return -1; return -1;
} }
int sock; struct addrinfo hints, *res, *cur;
struct sockaddr_in addr; int sock = 0, status = 0, family = -1;
struct hostent *ent = gethostbyname(url->host);
if (NULL == ent) { bzero(&hints, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
if ((status = getaddrinfo(addr, NULL, &hints, &res)) < 0) {
lm_error_set(LM_ERR_MPTPHostFail); lm_error_set(LM_ERR_MPTPHostFail);
return -1; return -1;
} }
if (ent->h_addrtype != AF_INET && ent->h_addrtype != AF_INET6) { for (cur = res; cur != NULL; cur = cur->ai_next) {
switch (cur->ai_family) {
case AF_INET:
family = cur->ai_family;
struct sockaddr_in *ipv4 = (struct sockaddr_in *)cur->ai_addr;
ipv4->sin_port = htons(port);
memcpy(saddr, cur->ai_addr, sizeof(struct sockaddr));
break;
case AF_INET6:
family = cur->ai_family;
struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)cur->ai_addr;
ipv6->sin6_port = htons(port);
memcpy(saddr, cur->ai_addr, sizeof(struct sockaddr));
break;
}
if (family != -1)
break;
}
freeaddrinfo(res);
if (family == -1) {
lm_error_set(LM_ERR_MPTPHostFail); lm_error_set(LM_ERR_MPTPHostFail);
return -1; return -1;
} }
if (NULL == ent->h_addr_list[0]) { if ((sock = socket(family, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
lm_error_set(LM_ERR_MPTPHostFail);
return -1;
}
addr.sin_addr.s_addr = *(long *)(ent->h_addr_list[0]);
addr.sin_family = ent->h_addrtype;
addr.sin_port = htons(url->port);
if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
lm_error_set(LM_ERR_MPTPSocketFail); lm_error_set(LM_ERR_MPTPSocketFail);
return -1; return -1;
} }
return sock;
}
void lm_mptp_close(int sock) {
close(sock);
}
int lm_mptp_client_connect(char *addr, uint16_t port) {
struct sockaddr saddr;
int sock;
bzero(&saddr, sizeof(saddr));
if ((sock = lm_mptp_socket(addr, port, &saddr)) < 0)
return -1;
struct timeval timeout; struct timeval timeout;
bzero(&timeout, sizeof(timeout)); bzero(&timeout, sizeof(timeout));
@ -80,13 +115,13 @@ int lm_mptp_connect(lm_url_t *url) {
timeout.tv_usec = 0; timeout.tv_usec = 0;
if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)) < 0) { if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)) < 0) {
lm_mptp_disconnect(sock);
lm_error_set(LM_ERR_MPTPSetsockopt); lm_error_set(LM_ERR_MPTPSetsockopt);
lm_mptp_close(sock);
return -1; return -1;
} }
if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { if (connect(sock, &saddr, sizeof(saddr)) < 0) {
lm_mptp_disconnect(sock); lm_mptp_close(sock);
lm_error_set(LM_ERR_MPTPConnectFail); lm_error_set(LM_ERR_MPTPConnectFail);
return -1; return -1;
} }
@ -94,102 +129,146 @@ int lm_mptp_connect(lm_url_t *url) {
return sock; return sock;
} }
bool lm_mptp_send(int sock, lm_mptp_t *packet) { bool lm_mptp_client_send(int sock, lm_mptp_t *packet) {
if (NULL == packet) {
lm_error_set(LM_ERR_ArgNULL);
return false;
}
if (MPTP_FLAGS_VERSION(packet) != MPTP_VERSION_SUPPORTED) { if (MPTP_FLAGS_VERSION(packet) != MPTP_VERSION_SUPPORTED) {
lm_error_set(LM_ERR_MPTPBadVersion); lm_error_set(LM_ERR_MPTPBadVersion);
return false; return false;
} }
size_t size = sizeof(packet->flags) + sizeof(packet->size); if (packet->header.size > MPTP_CHUNK_MAX) {
lm_error_set(LM_ERR_MPTPBadChunk);
return false;
}
if (NULL == packet->data || packet->size <= 0) { char buffer[sizeof(packet->header) + packet->header.size];
if (send(sock, packet, size, 0) < 0) { bzero(buffer, sizeof(buffer));
lm_error_set(LM_ERR_MPTPSendFail);
if (packet->header.size > 0)
memcpy(buffer + sizeof(packet->header), packet->data, packet->header.size);
packet->header.flags = htons(packet->header.flags);
packet->header.size = htons(packet->header.size);
memcpy(buffer, &packet->header, sizeof(packet->header));
if (send(sock, buffer, sizeof(buffer), 0) < 0) {
lm_error_set(LM_ERR_MPTPSendFail);
return false;
}
return true;
}
bool lm_mptp_client_recv(int sock, lm_mptp_t *packet) {
if (NULL == packet) {
lm_error_set(LM_ERR_ArgNULL);
return false;
}
char buffer[sizeof(packet->header) + MPTP_CHUNK_MAX];
bzero(buffer, sizeof(buffer));
if (recv(sock, buffer, sizeof(buffer), 0) < 0) {
if (ETIMEDOUT == errno || EAGAIN == errno) {
lm_error_set(LM_ERR_MPTPTimeout);
return false; return false;
} }
lm_error_set(LM_ERR_MPTPRecvFail);
return false;
}
memcpy(&packet->header, buffer, sizeof(packet->header));
packet->header.flags = ntohs(packet->header.flags);
packet->header.size = ntohs(packet->header.size);
if (packet->header.size > MPTP_CHUNK_MAX)
return true; return true;
}
if (send(sock, packet, size, 0) < 0) {
lm_error_set(LM_ERR_MPTPSendFail);
return false;
}
if (send(sock, packet->data, packet->size, 0) < 0) {
lm_error_set(LM_ERR_MPTPSendFail);
return false;
}
memcpy(packet->data, buffer + sizeof(packet->header), packet->header.size);
return true; return true;
} }
bool lm_mptp_send_data(int sock, char *data, size_t size) { int lm_mptp_server_listen(char *addr, uint16_t port) {
if (size > MPTP_CHUNK_MAX) { struct sockaddr saddr;
lm_error_set(LM_ERR_MPTPChunkFail); int sock;
bzero(&saddr, sizeof(saddr));
if ((sock = lm_mptp_socket(addr, port, &saddr)) < 0)
return -1;
if (bind(sock, &saddr, sizeof(struct sockaddr)) < 0) {
lm_mptp_close(sock);
lm_error_set(LM_ERR_MPTPBindFail);
return -1;
}
return sock;
}
bool lm_mptp_server_recv(int sock, lm_mptp_t *packet, struct sockaddr *addr) {
if (NULL == packet || NULL == addr) {
lm_error_set(LM_ERR_ArgNULL);
return false; return false;
} }
if (send(sock, data, size, 0) < 0) { socklen_t socklen = sizeof(struct sockaddr);
lm_error_set(LM_ERR_MPTPSendFail); char buffer[sizeof(packet->header) + MPTP_CHUNK_MAX];
bzero(buffer, sizeof(buffer));
bzero(packet, sizeof(lm_mptp_t));
if (recvfrom(sock, buffer, sizeof(buffer), 0, addr, &socklen) <= 0) {
lm_error_set(LM_ERR_MPTPRecvFail);
return false; return false;
} }
memcpy(&packet->header, buffer, sizeof(packet->header));
packet->header.flags = ntohs(packet->header.flags);
packet->header.size = ntohs(packet->header.size);
if (packet->header.size > MPTP_CHUNK_MAX)
return true;
memcpy(packet->data, buffer + sizeof(packet->header), sizeof(packet->header));
return true; return true;
} }
bool lm_mptp_recv(int sock, lm_mptp_t *packet) { bool lm_mptp_server_send(int sock, lm_mptp_t *packet, struct sockaddr *addr) {
if (recv(sock, &packet->flags, sizeof(packet->flags), 0) < 0) if (NULL == packet) {
goto recvfail; lm_error_set(LM_ERR_ArgNULL);
return false;
if (recv(sock, &packet->size, sizeof(packet->size), 0) < 0) }
goto recvfail;
if (MPTP_FLAGS_VERSION(packet) != MPTP_VERSION_SUPPORTED) { if (MPTP_FLAGS_VERSION(packet) != MPTP_VERSION_SUPPORTED) {
lm_error_set(LM_ERR_MPTPBadVersion); lm_error_set(LM_ERR_MPTPBadVersion);
return false; return false;
} }
if (NULL == packet->data) if (packet->header.size > MPTP_CHUNK_MAX) {
return true; lm_error_set(LM_ERR_MPTPBadChunk);
if (packet->size <= 0)
return true;
if (packet->size > MPTP_CHUNK_MAX) {
lm_error_set(LM_ERR_MPTPChunkFail);
return false; return false;
} }
if (recv(sock, &packet->data, packet->size, 0) < 0) socklen_t addrlen = sizeof(struct sockaddr);
goto recvfail; char buffer[sizeof(packet->header.size) + packet->header.size];
return true; bzero(buffer, sizeof(buffer));
recvfail: packet->header.flags = htons(packet->header.flags);
if (errno == ETIMEDOUT || errno == EAGAIN) packet->header.size = htons(packet->header.size);
lm_error_set(LM_ERR_MPTPTimeout);
else
lm_error_set(LM_ERR_MPTPRecvFail);
return false;
}
bool lm_mptp_recv_data(int sock, char *data, size_t size) { memcpy(buffer, &packet->header, sizeof(packet->header));
if (size > MPTP_CHUNK_MAX) { memcpy(buffer + sizeof(packet->header), packet->data, packet->header.size);
lm_error_set(LM_ERR_MPTPChunkFail);
return false;
}
if (recv(sock, data, size, 0) < 0) { if (sendto(sock, buffer, sizeof(buffer), 0, addr, addrlen) < 0) {
if (errno == ETIMEDOUT) lm_error_set(LM_ERR_MPTPSendFail);
lm_error_set(LM_ERR_MPTPTimeout);
else
lm_error_set(LM_ERR_MPTPRecvFail);
return false; return false;
} }
return true; return true;
} }
void lm_mptp_disconnect(int sock) {
close(sock);
}

12
src/pool.c
View File

@ -30,27 +30,27 @@ lm_pool_t *lm_pool_new(char *name, char *url) {
void lm_pool_test(lm_pool_t *pool) { void lm_pool_test(lm_pool_t *pool) {
lm_mptp_t packet; lm_mptp_t packet;
lm_mptp_init(&packet, true, MPTP_C2S_PING, true); lm_mptp_packet_init(&packet, true, MPTP_C2S_PING, true);
int sock = lm_mptp_connect(&pool->url); int sock = lm_mptp_client_connect(pool->url.host, pool->url.port);
if (sock == -1) { if (sock == -1) {
pool->available = false; pool->available = false;
return; return;
} }
if (!lm_mptp_send(sock, &packet)) { if (!lm_mptp_client_send(sock, &packet)) {
pool->available = false; pool->available = false;
goto end; goto end;
} }
if (!lm_mptp_recv(sock, &packet)) { if (!lm_mptp_client_recv(sock, &packet)) {
pool->available = false; pool->available = false;
goto end; goto end;
} }
pool->available = true; pool->available = MPTP_FLAGS_TYPE(&packet) == MPTP_S2C_PONG;
end: end:
lm_mptp_disconnect(sock); lm_mptp_close(sock);
return; return;
} }