libcor.h

   1 /**
   2  *      Connection oriented routing user space utils
   3  *      Copyright (C) 2009-2011
   4  *      Authors:
   5  *              Michael Blizek
   6  *
   7  *      This program is free software; you can redistribute it and/or
   8  *      modify it under the terms of the GNU General Public License
   9  *      as published by the Free Software Foundation; either version 2
  10  *      of the License, or (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License
  18  *      along with this program; if not, write to the Free Software
  19  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20  *      02110-1301, USA.
  21  */
  22
  23 #include <stdlib.h>
  24 #include <linux/types.h>
  25 #include <sys/socket.h>
  26
  27
  28 #define CRD_KTU_CONNECT 1
  29
  30 #define CRD_UTK_UP 1
  31 /*
  32  * CRD_KTU_CONNECT[4] length[4] flags[8] addrlen[4] addr[addrlen]
  33  *
  34  */
  35
  36
  37 #define CRD_UTK_CONNECTERROR 2
  38 /*
  39  * CRD_KTU_CONNECT[4] length[4] cookie[8] error[4]
  40  */
  41
  42
  43
  44 #define         AF_COR          40
  45 #define         PF_COR          AF_COR
  46
  47 #define PROTO_COR_RAW 0
  48 #define PROTO_COR_RDEAMON 1
  49
  50 typedef __u16 __be16;
  51
  52 #define SOCKADDRTYPE_PORT 1
  53 #define SOCKADDRTYPE_ADDRPORT 2
  54 struct cor_sockaddr {
  55         __SOCKADDR_COMMON (sin_); /* 2 bytes */
  56
  57         __be16 port;
  58         char addr[64];
  59 };
  60
  61 #define RESUME_TYPE_NONE 0
  62 #define RESUME_TYPE_READ 1
  63 #define RESUME_TYPE_WRITE 2
  64
  65 #define RESUME_READ_FUNC_NONE 0
  66 #define RESUME_READ_FUNC_RESP 1
  67 #define RESUME_READ_FUNC_NEIGHLIST 2
  68 #define RESUME_READ_FUNC_SERVICELIST 3
  69 #define RESUME_READ_FUNC_RDSOCK_CMD 4
  70
  71 #define NEIGHLIST_MAX_FIELDS 256
  72 #define ADDR_MAX_LEN 1024
  73 #define WRITE_BUF_SIZE 1024
  74
  75 struct listneigh_field {
  76         __u16 field;
  77         __u16 len;
  78 };
  79
  80 struct libcor_nonblock_resumeinfo_resp{
  81         int fd;
  82
  83         __u8 state;
  84         __u8 respcode;
  85
  86         __u16 reasoncode;
  87         __u32 reasonlen;
  88 };
  89
  90 struct libcor_nonblock_resumeinfo_neighlist{
  91         int fd;
  92
  93         void *ptr;
  94         void (*init)(void *ptr, __u32 numneighs);
  95         void (*next_neigh)(void *ptr, __u32 addrlen, char *addr);
  96
  97
  98         __u8 state;
  99
 100         __u8 respcode;
 101         __u32 len;
 102         __u32 numneighs;
 103         __u32 numfields;
 104
 105         struct listneigh_field fields[NEIGHLIST_MAX_FIELDS];
 106
 107         __u64 u;
 108         __u64 v;
 109
 110         __u32 fieldlen;
 111
 112         char addr[ADDR_MAX_LEN];
 113         __u32 addrlen;
 114         char latency;
 115 };
 116
 117 struct libcor_nonblock_resumeinfo_servicelist{
 118         int fd;
 119
 120         void *ptr;
 121         void (*init)(void *ptr, __u32 numservices);
 122         void (*next_service)(void *ptr, __be16 port);
 123
 124         __u8 state;
 125
 126         __u8 respcode;
 127         __u32 len;
 128         __u32 numservices;
 129
 130         __u64 q;
 131         __be16 port;
 132 };
 133
 134 struct libcor_nonblock_resumeinfo_rdsockcmd{
 135         int fd;
 136
 137         __u8 state;
 138
 139         char buf[8];
 140
 141         __u32 cmd;
 142         __u32 cmddatalen;
 143         char *cmddata;
 144 };
 145
 146 struct libcor_nonblock_resumeinfo{
 147         __u8 type;
 148
 149         union{
 150                 struct{
 151                         struct{
 152                                 __u8 state;
 153
 154                                 int fd;
 155                                 char *buf;
 156                                 __u32 len;
 157                                 __u32 *maxread;
 158
 159                                 __u32 totalread;
 160                         }read_fully;
 161
 162                         struct{
 163                                 __u8 state;
 164
 165                                 int fd;
 166                                 __u32 len;
 167                                 __u32 discarded;
 168                         }read_discard;
 169
 170                         struct{
 171                                 __u8 state;
 172
 173                                 int fd;
 174                                 __u32 *len;
 175                                 __u32 *maxread;
 176
 177                                 char buf[4];
 178                                 __u32 read;
 179                         }read_len;
 180
 181                         __u8 functype;
 182                         union{
 183                                 struct libcor_nonblock_resumeinfo_resp resp;
 184
 185                                 struct libcor_nonblock_resumeinfo_neighlist
 186                                                 neighlist;
 187
 188                                 struct libcor_nonblock_resumeinfo_servicelist
 189                                                 servicelist;
 190
 191                                 struct libcor_nonblock_resumeinfo_rdsockcmd
 192                                                 rdsock_cmd;
 193                         }funcdata;
 194                 }read;
 195
 196                 struct{
 197                         int fd;
 198
 199                         __u32 len;
 200                         __u32 totalsent;
 201
 202                         char buf[WRITE_BUF_SIZE];
 203                 }write;
 204         }data;
 205 };
 206
 207 #define RC_OK 0
 208 #define RC_CONNBROKEN 1
 209 #define RC_WOULDBLOCK 2
 210
 211 extern int resume_send(int fd, struct libcor_nonblock_resumeinfo *nr);
 212
 213 static inline int resume_send_ifneeded(int fd,
 214                 struct libcor_nonblock_resumeinfo *nr)
 215 {
 216         if (nr->type != RESUME_TYPE_WRITE)
 217                 return RC_OK;
 218
 219         return resume_send(fd, nr);
 220 }
 221
 222 extern int read_resp_nonblock(int fd, struct libcor_nonblock_resumeinfo *nr);
 223
 224 extern int read_resp(int fd);
 225
 226 extern int send_connect_neigh_nonblock(int fd,
 227                 struct libcor_nonblock_resumeinfo *nr,
 228                 __u32 addrlen, char *addr);
 229
 230 extern int send_connect_neigh(int fd, __u32 addrlen, char *addr);
 231
 232 extern int send_connect_port_nonblock(int fd,
 233                 struct libcor_nonblock_resumeinfo *nr,
 234                 __be16 port);
 235
 236 extern int send_connect_port(int fd, __be16 port);
 237
 238 extern int send_list_services_nonblock(int fd,
 239                 struct libcor_nonblock_resumeinfo *nr);
 240
 241 extern int send_list_services(int fd);
 242
 243 extern int read_service_list_nonblock(int fd,
 244                 struct libcor_nonblock_resumeinfo *nr, void *ptr,
 245                 void (*init)(void *ptr, __u32 numservices),
 246                 void (*next_service)(void *ptr, __be16 port));
 247
 248 extern int read_service_list(int fd, void *ptr,
 249                 void (*init)(void *ptr, __u32 numservices),
 250                 void (*next_service)(void *ptr, __be16 port));
 251
 252 extern int send_list_neigh_nonblock(int fd,
 253                 struct libcor_nonblock_resumeinfo *nr);
 254
 255 extern int send_list_neigh(int fd);
 256
 257 extern int read_neigh_list_nonblock(int fd,
 258                 struct libcor_nonblock_resumeinfo *nr,
 259                 void *ptr,
 260                 void (*init)(void *ptr, __u32 numneighs),
 261                 void (*next_neigh)(void *ptr, __u32 addrlen, char *addr));
 262
 263 extern int read_neigh_list(int fd, void *ptr,
 264                 void (*init)(void *ptr, __u32 numneighs),
 265                 void (*next_neigh)(void *ptr, __u32 addrlen, char *addr));
 266
 267
 268 #define SOL_COR         280
 269
 270 #define COR_PASS_ON_CLOSE 1
 271
 272 #define CONNECTERROR_ACCES 1
 273 #define CONNECTERROR_NETUNREACH 2
 274 #define CONNECTERROR_TIMEDOUT 3
 275 #define CONNECTERROR_REFUSED 4
 276
 277 extern int pass_socket(int fd, __u64 cookie);
 278
 279 extern int send_rdsock_connecterror_nonblock(int fd,
 280                 struct libcor_nonblock_resumeinfo *nr,
 281                 __u64 cookie, __u32 error);
 282
 283 extern int send_rdsock_connecterror(int fd, __u64 cookie, __u32 error);
 284
 285 extern int send_rdsock_up_nonblock(int fd,
 286                 struct libcor_nonblock_resumeinfo *nr,
 287                 char *addr, __u32 addrlen);
 288
 289 extern int send_rdsock_up(int fd, char *addr, __u32 addrlen);
 290
 291 struct rdsock_cmd{
 292         __u32 cmd;
 293         char *cmddata;
 294         __u32 cmddatalen;
 295 };
 296
 297 extern int parse_rdsock_connect(void *ptr, struct rdsock_cmd *cmd,
 298                 int (*proc_connect)(void *ptr, __u64 cookie,
 299                 struct cor_sockaddr *addr));
 300
 301 static inline void free_rdsockcmd_data(struct rdsock_cmd *cmd)
 302 {
 303         free(cmd->cmddata);
 304         cmd->cmddata = 0;
 305 }
 306
 307 extern int read_rdsock_cmd_nonblock(int fd,
 308                 struct libcor_nonblock_resumeinfo *nr,
 309                 struct rdsock_cmd *cmd);
 310
 311 extern int read_rdsock_cmd(int fd, struct rdsock_cmd *cmd);