[linux-2.6-block.git] / tools / usb / usbip / src / usbip_network.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 2005-2007 Takahiro Hirofuchi
 */

#ifndef __USBIP_NETWORK_H
#define __USBIP_NETWORK_H

#ifdef HAVE_CONFIG_H
#include "../config.h"
#endif

#include <sys/types.h>

#include <stdint.h>

extern int usbip_port;
extern char *usbip_port_string;
void usbip_setup_port_number(char *arg);

/* ---------------------------------------------------------------------- */
/* Common header for all the kinds of PDUs. */
struct op_common {
	uint16_t version;

#define OP_REQUEST	(0x80 << 8)
#define OP_REPLY	(0x00 << 8)
	uint16_t code;

	/* status codes defined in usbip_common.h */
	uint32_t status; /* op_code status (for reply) */

} __attribute__((packed));

/* ---------------------------------------------------------------------- */
/* Dummy Code */
#define OP_UNSPEC	0x00
#define OP_REQ_UNSPEC	OP_UNSPEC
#define OP_REP_UNSPEC	OP_UNSPEC

/* ---------------------------------------------------------------------- */
/* Retrieve USB device information. (still not used) */
#define OP_DEVINFO	0x02
#define OP_REQ_DEVINFO	(OP_REQUEST | OP_DEVINFO)
#define OP_REP_DEVINFO	(OP_REPLY   | OP_DEVINFO)

struct op_devinfo_request {
	char busid[SYSFS_BUS_ID_SIZE];
} __attribute__((packed));

struct op_devinfo_reply {
	struct usbip_usb_device udev;
	struct usbip_usb_interface uinf[];
} __attribute__((packed));

/* ---------------------------------------------------------------------- */
/* Import a remote USB device. */
#define OP_IMPORT	0x03
#define OP_REQ_IMPORT	(OP_REQUEST | OP_IMPORT)
#define OP_REP_IMPORT   (OP_REPLY   | OP_IMPORT)

struct op_import_request {
	char busid[SYSFS_BUS_ID_SIZE];
} __attribute__((packed));

struct op_import_reply {
	struct usbip_usb_device udev;
//	struct usbip_usb_interface uinf[];
} __attribute__((packed));

#define PACK_OP_IMPORT_REQUEST(pack, request)  do {\
} while (0)

#define PACK_OP_IMPORT_REPLY(pack, reply)  do {\
	usbip_net_pack_usb_device(pack, &(reply)->udev);\
} while (0)

/* ---------------------------------------------------------------------- */
/* Export a USB device to a remote host. */
#define OP_EXPORT	0x06
#define OP_REQ_EXPORT	(OP_REQUEST | OP_EXPORT)
#define OP_REP_EXPORT	(OP_REPLY   | OP_EXPORT)

struct op_export_request {
	struct usbip_usb_device udev;
} __attribute__((packed));

struct op_export_reply {
	int returncode;
} __attribute__((packed));


#define PACK_OP_EXPORT_REQUEST(pack, request)  do {\
	usbip_net_pack_usb_device(pack, &(request)->udev);\
} while (0)

#define PACK_OP_EXPORT_REPLY(pack, reply)  do {\
} while (0)

/* ---------------------------------------------------------------------- */
/* un-Export a USB device from a remote host. */
#define OP_UNEXPORT	0x07
#define OP_REQ_UNEXPORT	(OP_REQUEST | OP_UNEXPORT)
#define OP_REP_UNEXPORT	(OP_REPLY   | OP_UNEXPORT)

struct op_unexport_request {
	struct usbip_usb_device udev;
} __attribute__((packed));

struct op_unexport_reply {
	int returncode;
} __attribute__((packed));

#define PACK_OP_UNEXPORT_REQUEST(pack, request)  do {\
	usbip_net_pack_usb_device(pack, &(request)->udev);\
} while (0)

#define PACK_OP_UNEXPORT_REPLY(pack, reply)  do {\
} while (0)

/* ---------------------------------------------------------------------- */
/* Negotiate IPSec encryption key. (still not used) */
#define OP_CRYPKEY	0x04
#define OP_REQ_CRYPKEY	(OP_REQUEST | OP_CRYPKEY)
#define OP_REP_CRYPKEY	(OP_REPLY   | OP_CRYPKEY)

struct op_crypkey_request {
	/* 128bit key */
	uint32_t key[4];
} __attribute__((packed));

struct op_crypkey_reply {
	uint32_t __reserved;
} __attribute__((packed));


/* ---------------------------------------------------------------------- */
/* Retrieve the list of exported USB devices. */
#define OP_DEVLIST	0x05
#define OP_REQ_DEVLIST	(OP_REQUEST | OP_DEVLIST)
#define OP_REP_DEVLIST	(OP_REPLY   | OP_DEVLIST)

struct op_devlist_request {
} __attribute__((packed));

struct op_devlist_reply {
	uint32_t ndev;
	/* followed by reply_extra[] */
} __attribute__((packed));

struct op_devlist_reply_extra {
	struct usbip_usb_device    udev;
	struct usbip_usb_interface uinf[];
} __attribute__((packed));

#define PACK_OP_DEVLIST_REQUEST(pack, request)  do {\
} while (0)

#define PACK_OP_DEVLIST_REPLY(pack, reply)  do {\
	(reply)->ndev = usbip_net_pack_uint32_t(pack, (reply)->ndev);\
} while (0)

uint32_t usbip_net_pack_uint32_t(int pack, uint32_t num);
uint16_t usbip_net_pack_uint16_t(int pack, uint16_t num);
void usbip_net_pack_usb_device(int pack, struct usbip_usb_device *udev);
void usbip_net_pack_usb_interface(int pack, struct usbip_usb_interface *uinf);

ssize_t usbip_net_recv(int sockfd, void *buff, size_t bufflen);
ssize_t usbip_net_send(int sockfd, void *buff, size_t bufflen);
int usbip_net_send_op_common(int sockfd, uint32_t code, uint32_t status);
int usbip_net_recv_op_common(int sockfd, uint16_t *code, int *status);
int usbip_net_set_reuseaddr(int sockfd);
int usbip_net_set_nodelay(int sockfd);
int usbip_net_set_keepalive(int sockfd);
int usbip_net_set_v6only(int sockfd);
int usbip_net_tcp_connect(char *hostname, char *port);

#endif /* __USBIP_NETWORK_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
0945b4fe TH	2	/*
	3	* Copyright (C) 2005-2007 Takahiro Hirofuchi
	4	*/
	5
1e35d87d	6	#ifndef __USBIP_NETWORK_H
1e35d87d	7	#define __USBIP_NETWORK_H
0945b4fe	8
1e35d87d	9	#ifdef HAVE_CONFIG_H
	10	#include "../config.h"
	11	#endif
0945b4fe	12
1e35d87d	13	#include <sys/types.h>
0945b4fe	14
1e35d87d	15	#include <stdint.h>
0945b4fe	16
7182f8f8 AF	17	extern int usbip_port;
	18	extern char *usbip_port_string;
	19	void usbip_setup_port_number(char *arg);
0945b4fe TH	20
	21	/* ---------------------------------------------------------------------- */
	22	/* Common header for all the kinds of PDUs. */
	23	struct op_common {
	24	uint16_t version;
	25
	26	#define OP_REQUEST (0x80 << 8)
	27	#define OP_REPLY (0x00 << 8)
	28	uint16_t code;
	29
f6bcbf2e	30	/* status codes defined in usbip_common.h */
0945b4fe TH	31	uint32_t status; /* op_code status (for reply) */
	32
	33	} __attribute__((packed));
	34
0945b4fe TH	35	/* ---------------------------------------------------------------------- */
	36	/* Dummy Code */
	37	#define OP_UNSPEC 0x00
	38	#define OP_REQ_UNSPEC OP_UNSPEC
	39	#define OP_REP_UNSPEC OP_UNSPEC
	40
	41	/* ---------------------------------------------------------------------- */
	42	/* Retrieve USB device information. (still not used) */
	43	#define OP_DEVINFO 0x02
	44	#define OP_REQ_DEVINFO (OP_REQUEST \| OP_DEVINFO)
	45	#define OP_REP_DEVINFO (OP_REPLY \| OP_DEVINFO)
	46
	47	struct op_devinfo_request {
	48	char busid[SYSFS_BUS_ID_SIZE];
	49	} __attribute__((packed));
	50
	51	struct op_devinfo_reply {
35dd0c2d	52	struct usbip_usb_device udev;
35dd0c2d	53	struct usbip_usb_interface uinf[];
0945b4fe TH	54	} __attribute__((packed));
0945b4fe TH	55
0945b4fe TH	56	/* ---------------------------------------------------------------------- */
	57	/* Import a remote USB device. */
	58	#define OP_IMPORT 0x03
	59	#define OP_REQ_IMPORT (OP_REQUEST \| OP_IMPORT)
	60	#define OP_REP_IMPORT (OP_REPLY \| OP_IMPORT)
	61
	62	struct op_import_request {
	63	char busid[SYSFS_BUS_ID_SIZE];
	64	} __attribute__((packed));
	65
	66	struct op_import_reply {
35dd0c2d	67	struct usbip_usb_device udev;
35dd0c2d	68	// struct usbip_usb_interface uinf[];
0945b4fe TH	69	} __attribute__((packed));
	70
	71	#define PACK_OP_IMPORT_REQUEST(pack, request) do {\
	72	} while (0)
	73
	74	#define PACK_OP_IMPORT_REPLY(pack, reply) do {\
3c6e9e8f	75	usbip_net_pack_usb_device(pack, &(reply)->udev);\
0945b4fe TH	76	} while (0)
0945b4fe TH	77
0945b4fe TH	78	/* ---------------------------------------------------------------------- */
	79	/* Export a USB device to a remote host. */
	80	#define OP_EXPORT 0x06
	81	#define OP_REQ_EXPORT (OP_REQUEST \| OP_EXPORT)
	82	#define OP_REP_EXPORT (OP_REPLY \| OP_EXPORT)
	83
	84	struct op_export_request {
35dd0c2d	85	struct usbip_usb_device udev;
0945b4fe TH	86	} __attribute__((packed));
	87
	88	struct op_export_reply {
9abec452	89	int returncode;
0945b4fe TH	90	} __attribute__((packed));
	91
	92
	93	#define PACK_OP_EXPORT_REQUEST(pack, request) do {\
3c6e9e8f	94	usbip_net_pack_usb_device(pack, &(request)->udev);\
0945b4fe TH	95	} while (0)
	96
	97	#define PACK_OP_EXPORT_REPLY(pack, reply) do {\
	98	} while (0)
	99
	100	/* ---------------------------------------------------------------------- */
	101	/* un-Export a USB device from a remote host. */
	102	#define OP_UNEXPORT 0x07
	103	#define OP_REQ_UNEXPORT (OP_REQUEST \| OP_UNEXPORT)
	104	#define OP_REP_UNEXPORT (OP_REPLY \| OP_UNEXPORT)
	105
	106	struct op_unexport_request {
35dd0c2d	107	struct usbip_usb_device udev;
0945b4fe TH	108	} __attribute__((packed));
	109
	110	struct op_unexport_reply {
9abec452	111	int returncode;
0945b4fe TH	112	} __attribute__((packed));
	113
	114	#define PACK_OP_UNEXPORT_REQUEST(pack, request) do {\
3c6e9e8f	115	usbip_net_pack_usb_device(pack, &(request)->udev);\
0945b4fe TH	116	} while (0)
	117
	118	#define PACK_OP_UNEXPORT_REPLY(pack, reply) do {\
	119	} while (0)
	120
0945b4fe TH	121	/* ---------------------------------------------------------------------- */
	122	/* Negotiate IPSec encryption key. (still not used) */
	123	#define OP_CRYPKEY 0x04
	124	#define OP_REQ_CRYPKEY (OP_REQUEST \| OP_CRYPKEY)
	125	#define OP_REP_CRYPKEY (OP_REPLY \| OP_CRYPKEY)
	126
	127	struct op_crypkey_request {
	128	/* 128bit key */
	129	uint32_t key[4];
	130	} __attribute__((packed));
	131
	132	struct op_crypkey_reply {
	133	uint32_t __reserved;
	134	} __attribute__((packed));
	135
	136
	137	/* ---------------------------------------------------------------------- */
	138	/* Retrieve the list of exported USB devices. */
	139	#define OP_DEVLIST 0x05
	140	#define OP_REQ_DEVLIST (OP_REQUEST \| OP_DEVLIST)
	141	#define OP_REP_DEVLIST (OP_REPLY \| OP_DEVLIST)
	142
	143	struct op_devlist_request {
	144	} __attribute__((packed));
	145
	146	struct op_devlist_reply {
	147	uint32_t ndev;
	148	/* followed by reply_extra[] */
	149	} __attribute__((packed));
	150
	151	struct op_devlist_reply_extra {
35dd0c2d	152	struct usbip_usb_device udev;
35dd0c2d	153	struct usbip_usb_interface uinf[];
0945b4fe TH	154	} __attribute__((packed));
	155
	156	#define PACK_OP_DEVLIST_REQUEST(pack, request) do {\
	157	} while (0)
	158
	159	#define PACK_OP_DEVLIST_REPLY(pack, reply) do {\
585c91f4	160	(reply)->ndev = usbip_net_pack_uint32_t(pack, (reply)->ndev);\
0945b4fe TH	161	} while (0)
0945b4fe TH	162
585c91f4 SK	163	uint32_t usbip_net_pack_uint32_t(int pack, uint32_t num);
585c91f4 SK	164	uint16_t usbip_net_pack_uint16_t(int pack, uint16_t num);
3c6e9e8f	165	void usbip_net_pack_usb_device(int pack, struct usbip_usb_device *udev);
	166	void usbip_net_pack_usb_interface(int pack, struct usbip_usb_interface *uinf);
	167
	168	ssize_t usbip_net_recv(int sockfd, void *buff, size_t bufflen);
	169	ssize_t usbip_net_send(int sockfd, void *buff, size_t bufflen);
	170	int usbip_net_send_op_common(int sockfd, uint32_t code, uint32_t status);
ad81b15d	171	int usbip_net_recv_op_common(int sockfd, uint16_t code, int status);
3c6e9e8f	172	int usbip_net_set_reuseaddr(int sockfd);
	173	int usbip_net_set_nodelay(int sockfd);
	174	int usbip_net_set_keepalive(int sockfd);
f49ad35c	175	int usbip_net_set_v6only(int sockfd);
1e35d87d	176	int usbip_net_tcp_connect(char hostname, char port);
0945b4fe	177
1e35d87d	178	#endif /* __USBIP_NETWORK_H */