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

/*
 * Copyright 2025 Shota FUJI
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * ===
 *
 * C89 header file for Plac core's C API.
 * This file is not checked against a generated library file: carefully write and review
 * definitions and implementations.
 */

#ifndef PLAC_CORE_H
#define PLAC_CORE_H

#include <sys/socket.h>

/* Server */
typedef struct {
	struct sockaddr sockaddr;
	socklen_t const addrlen;
	char const * const id;
	unsigned int const id_len;
	char const * const name;
	unsigned int const name_len;
	const char * const version;
	unsigned int const version_len;
} plac_server;

plac_server *plac_server_dupe(plac_server*);
void plac_server_free(plac_server*);

/* ScanOptions */
typedef struct {
	unsigned int count;
	unsigned int receive_window_ms;
} plac_server_scan_options;

void plac_server_scan_options_init(plac_server_scan_options*);

/* ScanResultCode */
typedef enum {
	PLAC_SCAN_OK = 0,
	PLAC_SCAN_UNKNOWN_ERROR = 1,
	PLAC_SCAN_OUT_OF_MEMORY = 2,
	PLAC_SCAN_SOCKET_SETUP_ERROR = 3,
	PLAC_SCAN_UDP_SEND_ERROR = 4,
	PLAC_SCAN_UDP_RECV_ERROR = 5,
	PLAC_SCAN_NULL_POINTER_ARGS = 6,
	PLAC_SCAN_SOCKET_PERMISSION_ERROR = 7,
	PLAC_SCAN_TOO_MANY_SOCKET_ERROR = 8,
	PLAC_SCAN_INVALID_RECEIVE_WINDOW = 9,
	PLAC_SCAN_NETWORK_UNAVAILABLE = 10,
} plac_scan_result_code;

/* ScanResult */

typedef struct {
	plac_scan_result_code const code;
	void * const __servers;
	unsigned int const __i;
} plac_scan_result;

plac_server *plac_scan_result_next(plac_scan_result*);
void plac_scan_result_reset(plac_scan_result*);
void plac_scan_result_free(plac_scan_result*);

/* FindResult */

typedef struct {
	plac_scan_result_code const code;
	plac_server * const server;
} plac_find_result;

void plac_find_result_free(plac_find_result*);

/* ServerScanner */

typedef struct {
	const int *__sockfd;
} plac_server_scanner;

plac_server_scanner *plac_server_scanner_make();
void plac_server_scanner_free(plac_server_scanner*);
plac_scan_result *plac_server_scanner_scan(plac_server_scanner*, plac_server_scan_options*);
plac_find_result *plac_server_scanner_find(plac_server_scanner*, char * const, unsigned int);

/* Application */
typedef struct {
	struct sockaddr __addr;
	void *__conn;
} plac_application;

plac_application *plac_application_make_from_server(plac_server*);
char *plac_application_connect(plac_application*, char*);
void plac_application_free(plac_application*);

#endif