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_SUPPORTEDVERSIONS 1
  29 #define CRD_KTU_CONNECT 2
  30
  31 #define CRD_UTK_VERSION 1
  32 /*
  33  * CRD_UTK_VERSION[4] length[4] version[4]
  34  *
  35  */
  36
  37 #define CRD_UTK_UP 2
  38 /*
  39  * CRD_UTK_UP[4] length[4] flags[8] addrlen[4] addr[addrlen]
  40  *
  41  */
  42
  43
  44 #define CRD_UTK_CONNECTERROR 3
  45 /*
  46  * CRD_UTK_CONNECTERROR[4] length[4] cookie[8] error[4]
  47  */
  48
  49
  50
  51 #define         AF_COR          40
  52 #define         PF_COR          AF_COR
  53
  54 #define PROTO_COR_RAW 0
  55 #define PROTO_COR_RDEAMON 1
  56
  57 typedef __u16 __be16;
  58
  59 #define SOCKADDRTYPE_PORT 1
  60 #define SOCKADDRTYPE_ADDRPORT 2
  61 struct cor_sockaddr {
  62         __SOCKADDR_COMMON (sin_); /* 2 bytes */
  63
  64         __be16 port;
  65         char addr[64];
  66 };
  67
  68 #define RESUME_TYPE_NONE 0
  69 #define RESUME_TYPE_READ 1
  70 #define RESUME_TYPE_WRITE 2
  71
  72 #define RESUME_READ_FUNC_NONE 0
  73 #define RESUME_READ_FUNC_RESP 1
  74 #define RESUME_READ_FUNC_NEIGHLIST 2
  75 #define RESUME_READ_FUNC_SERVICELIST 3
  76 #define RESUME_READ_FUNC_RDSOCK_CMD 4
  77
  78 #define NEIGHLIST_MAX_FIELDS 256
  79 #define ADDR_MAX_LEN 1024
  80 #define WRITE_BUF_SIZE 1024
  81
  82 struct listneigh_field {
  83         __u16 field;
  84         __u16 len;
  85 };
  86
  87 struct libcor_nonblock_resumeinfo_resp{
  88         int fd;
  89
  90         __u8 state;
  91         __u8 respcode;
  92
  93         __u16 reasoncode;
  94         __u32 reasonlen;
  95 };
  96
  97 struct libcor_nonblock_resumeinfo_neighlist{
  98         int fd;
  99
 100         void *ptr;
 101         void (*init)(void *ptr, __u32 numneighs);
 102         void (*next_neigh)(void *ptr, __u32 addrlen, char *addr);
 103
 104
 105         __u8 state;
 106
 107         __u8 respcode;
 108         __u32 len;
 109         __u32 numneighs;
 110         __u32 numfields;
 111
 112         struct listneigh_field fields[NEIGHLIST_MAX_FIELDS];
 113
 114         __u64 u;
 115         __u64 v;
 116
 117         __u32 fieldlen;
 118
 119         char addr[ADDR_MAX_LEN];
 120         __u32 addrlen;
 121         char latency;
 122 };
 123
 124 struct libcor_nonblock_resumeinfo_servicelist{
 125         int fd;
 126
 127         void *ptr;
 128         void (*init)(void *ptr, __u32 numservices);
 129         void (*next_service)(void *ptr, __be16 port);
 130
 131         __u8 state;
 132
 133         __u8 respcode;
 134         __u32 len;
 135         __u32 numservices;
 136
 137         __u64 q;
 138         __be16 port;
 139 };
 140
 141 struct libcor_nonblock_resumeinfo_rdsockcmd{
 142         int fd;
 143
 144         __u8 state;
 145
 146         char buf[8];
 147
 148         __u32 cmd;
 149         __u32 cmddatalen;
 150         char *cmddata;
 151 };
 152
 153 struct libcor_nonblock_resumeinfo{
 154         __u8 type;
 155
 156         union{
 157                 struct{
 158                         struct{
 159                                 __u8 state;
 160
 161                                 int fd;
 162                                 char *buf;
 163                                 __u32 len;
 164                                 __u32 *maxread;
 165
 166                                 __u32 totalread;
 167                         }read_fully;
 168
 169                         struct{
 170                                 __u8 state;
 171
 172                                 int fd;
 173                                 __u32 len;
 174                                 __u32 discarded;
 175                         }read_discard;
 176
 177                         struct{
 178                                 __u8 state;
 179
 180                                 int fd;
 181                                 __u32 *len;
 182                                 __u32 *maxread;
 183
 184                                 char buf[4];
 185                                 __u32 read;
 186                         }read_len;
 187
 188                         __u8 functype;
 189                         union{
 190                                 struct libcor_nonblock_resumeinfo_resp resp;
 191
 192                                 struct libcor_nonblock_resumeinfo_neighlist
 193                                                 neighlist;
 194
 195                                 struct libcor_nonblock_resumeinfo_servicelist
 196                                                 servicelist;
 197
 198                                 struct libcor_nonblock_resumeinfo_rdsockcmd
 199                                                 rdsock_cmd;
 200                         }funcdata;
 201                 }read;
 202
 203                 struct{
 204                         int fd;
 205
 206                         __u32 len;
 207                         __u32 totalsent;
 208
 209                         char buf[WRITE_BUF_SIZE];
 210                 }write;
 211         }data;
 212 };
 213
 214 #define RC_OK 0
 215 #define RC_CONNBROKEN 1
 216 #define RC_WOULDBLOCK 2
 217
 218 extern int resume_send(int fd, struct libcor_nonblock_resumeinfo *nr);
 219
 220 static inline int resume_send_ifneeded(int fd,
 221                 struct libcor_nonblock_resumeinfo *nr)
 222 {
 223         if (nr->type != RESUME_TYPE_WRITE)
 224                 return RC_OK;
 225
 226         return resume_send(fd, nr);
 227 }
 228
 229 extern int read_resp_nonblock(int fd, struct libcor_nonblock_resumeinfo *nr);
 230
 231 extern int read_resp(int fd);
 232
 233 extern int send_connect_neigh_nonblock(int fd,
 234                 struct libcor_nonblock_resumeinfo *nr,
 235                 __u32 addrlen, char *addr);
 236
 237 extern int send_connect_neigh(int fd, __u32 addrlen, char *addr);
 238
 239 extern int send_connect_port_nonblock(int fd,
 240                 struct libcor_nonblock_resumeinfo *nr,
 241                 __be16 port);
 242
 243 extern int send_connect_port(int fd, __be16 port);
 244
 245 extern int send_list_services_nonblock(int fd,
 246                 struct libcor_nonblock_resumeinfo *nr);
 247
 248 extern int send_list_services(int fd);
 249
 250 extern int read_service_list_nonblock(int fd,
 251                 struct libcor_nonblock_resumeinfo *nr, void *ptr,
 252                 void (*init)(void *ptr, __u32 numservices),
 253                 void (*next_service)(void *ptr, __be16 port));
 254
 255 extern int read_service_list(int fd, void *ptr,
 256                 void (*init)(void *ptr, __u32 numservices),
 257                 void (*next_service)(void *ptr, __be16 port));
 258
 259 extern int send_list_neigh_nonblock(int fd,
 260                 struct libcor_nonblock_resumeinfo *nr);
 261
 262 extern int send_list_neigh(int fd);
 263
 264 extern int read_neigh_list_nonblock(int fd,
 265                 struct libcor_nonblock_resumeinfo *nr,
 266                 void *ptr,
 267                 void (*init)(void *ptr, __u32 numneighs),
 268                 void (*next_neigh)(void *ptr, __u32 addrlen, char *addr));
 269
 270 extern int read_neigh_list(int fd, void *ptr,
 271                 void (*init)(void *ptr, __u32 numneighs),
 272                 void (*next_neigh)(void *ptr, __u32 addrlen, char *addr));
 273
 274
 275 #define SOL_COR         280
 276
 277 #define COR_PASS_ON_CLOSE 1
 278
 279 #define CONNECTERROR_ACCES 1
 280 #define CONNECTERROR_NETUNREACH 2
 281 #define CONNECTERROR_TIMEDOUT 3
 282 #define CONNECTERROR_REFUSED 4
 283
 284 extern int pass_socket(int fd, __u64 cookie);
 285
 286 extern int send_rdsock_version_nonblock(int fd,
 287                 struct libcor_nonblock_resumeinfo *nr, __u32 version);
 288
 289 extern int send_rdsock_version(int fd, __u32 version);
 290
 291 extern int send_rdsock_up_nonblock(int fd,
 292                 struct libcor_nonblock_resumeinfo *nr,
 293                 char *addr, __u32 addrlen);
 294
 295 extern int send_rdsock_up(int fd, char *addr, __u32 addrlen);
 296
 297 extern int send_rdsock_connecterror_nonblock(int fd,
 298                 struct libcor_nonblock_resumeinfo *nr,
 299                 __u64 cookie, __u32 error);
 300
 301 extern int send_rdsock_connecterror(int fd, __u64 cookie, __u32 error);
 302
 303 struct rdsock_cmd{
 304         __u32 cmd;
 305         char *cmddata;
 306         __u32 cmddatalen;
 307 };
 308
 309 extern int parse_rdsock_supported_versions(struct rdsock_cmd *cmd,
 310                 __u32 *versionmin, __u32 *versionmax);
 311
 312 extern int parse_rdsock_connect(void *ptr, struct rdsock_cmd *cmd,
 313                 int (*proc_connect)(void *ptr, __u64 cookie,
 314                 struct cor_sockaddr *addr));
 315
 316 static inline void free_rdsockcmd_data(struct rdsock_cmd *cmd)
 317 {
 318         free(cmd->cmddata);
 319         cmd->cmddata = 0;
 320 }
 321
 322 extern int read_rdsock_cmd_nonblock(int fd,
 323                 struct libcor_nonblock_resumeinfo *nr,
 324                 struct rdsock_cmd *cmd);
 325
 326 extern int read_rdsock_cmd(int fd, struct rdsock_cmd *cmd);