1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103
104. 104
105. 105
106. 106
107. 107
108. 108
109. 109
110. 110
111. 111
112. 112
113. 113
114. 114
115. 115
116. 116
117. 117
118. 118
119. 119
120. 120
121. 121

// Copyright 2025 Shota FUJI
//
// Licensed under the Zero-Clause BSD License or the Apache License, Version 2.0, at your option.
// You may not use, copy, modify, or distribute this file except according to those terms. You can
// find a copy of the Zero-Clause BSD License at LICENSES/0BSD.txt, and a copy of the Apache License,
// Version 2.0 at LICENSES/Apache-2.0.txt. You may also obtain a copy of the Apache License, Version
// 2.0 at <https://www.apache.org/licenses/LICENSE-2.0>
//
// SPDX-License-Identifier: 0BSD OR Apache-2.0

#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>

#include <sood.h>

int main(int argc, char **argv) {
	struct sockaddr_in multicast_addr;
	multicast_addr.sin_family = AF_INET;
	// Port is network byte order both in Linux and macOS
	multicast_addr.sin_port = htons(sood_discovery_server_udp_port);
	#ifdef __linux__
	// Linux uses network byte order for IP addr part. Great consistency.
	multicast_addr.sin_addr.s_addr = sood_discovery_multicast_ipv4_address_be;
	#else
	// Windows and macOS seem to use host byte order. fuck.
	multicast_addr.sin_addr.s_addr = ntohl(sood_discovery_multicast_ipv4_address_be);
	#endif
	printf("ADDR=0x%x:%d\n", multicast_addr.sin_addr.s_addr, sood_discovery_server_udp_port);

	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0) {
		printf("Failed to create socket: %d\n", errno);
		return 1;
	}

	if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &(int){1}, sizeof(int)) < 0) {
		printf("Failed to set SO_REUSEADDR=1: %d\n", errno);
		close(sockfd);
		return 1;
	}

	struct timeval timeout;
	timeout.tv_sec = 5;
	timeout.tv_usec = 0;

	if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
		printf("Failed to set SO_RCVTIMEO: %d\n", errno);
		close(sockfd);
		return 1;
	}

	while (1) {
		if (
			sendto(
				sockfd,
				sood_discovery_query_prebuilt,
				sizeof(sood_discovery_query_prebuilt),
				0,
				(struct sockaddr*)&multicast_addr,
				sizeof(multicast_addr)
			) < 0
		) {
			printf("Failed to send: %d\n", errno);
			close(sockfd);
			return 1;
		}

		char received[512];
		ssize_t received_size = recv(sockfd, received, sizeof(received), 0);
		if (received_size < 0) {
			if (errno == EAGAIN || errno == EWOULDBLOCK) {
				printf("Retrying...\n");
				continue;
			}

			printf("Failed to recv: %d\n", errno);
			close(sockfd);
			return 1;
		}

		sood_message msg;
		sood_parse_result result = sood_parse(&msg, received, received_size);
		if (result != SOOD_PARSE_OK) {
			printf("Parse error: %d\n", result);
			close(sockfd);
			return 2;
		}

		sood_message_iter iter;
		sood_message_iterator(&iter, &msg);

		sood_message_property property;
		char key[UINT8_MAX];
		char value[UINT16_MAX];
		while (1) {
			sood_message_read_property_result result = sood_message_iter_next(&iter, &property);

			switch (result) {
				case SOOD_READ_PROPERTY_DONE:
					close(sockfd);
					return 0;
				case SOOD_READ_PROPERTY_OK:
					memset(key, 0, sizeof(key));
					memset(value, 0, sizeof(value));
					memcpy(key, property.key_ptr, property.key_len);
					memcpy(value, property.value_ptr, property.value_len);
					printf("%s=%s\n", key, value);
					break;
				default:
					printf("ERR: %d\n", result);
					close(sockfd);
					return 1;
			}
		}
	}
}