This cleans up the port names in various functions and data structures.
Tries to get rid of ambiguous "port" fields. A few changes will be in
the next commit which has some functional updates as well.
cfg->max_tree_depth = TR_DEFAULT_MAX_TREE_DEPTH;
cfg->tids_port = TR_DEFAULT_TIDS_PORT;
cfg->trps_port = TR_DEFAULT_TRPS_PORT;
- cfg->monitoring_port = TR_DEFAULT_MONITORING_PORT;
+ cfg->mons_port = TR_DEFAULT_MONITORING_PORT;
cfg->cfg_poll_interval = TR_CFGWATCH_DEFAULT_POLL;
cfg->cfg_settling_time = TR_CFGWATCH_DEFAULT_SETTLE;
cfg->trp_connect_interval = TR_DEFAULT_TRP_CONNECT_INTERVAL;
NOPARSE_UNLESS(tr_cfg_parse_boolean(jmon, "enabled", &enabled));
if (enabled) {
- NOPARSE_UNLESS(tr_cfg_parse_unsigned(jmon, "port", &(trc->internal->monitoring_port)));
+ NOPARSE_UNLESS(tr_cfg_parse_unsigned(jmon, "port", &(trc->internal->mons_port)));
NOPARSE_UNLESS(tr_cfg_parse_gss_names(trc->internal,
json_object_get(jmon, "authorized_credentials"),
&(trc->internal->monitoring_credentials)));
* @param port TCP port to connect
* @return 0 on success, -1 on failure
*/
-int tr_gssc_open_connection(TR_GSSC_INSTANCE *gssc, const char *server, unsigned int port)
+int tr_gssc_open_connection(TR_GSSC_INSTANCE *gssc, const char *server, int port)
{
+ if ((port <= 0) || (port > 65535)) {
+ tr_err("tr_gssc_open_connection: invalid port requested (%d)", port);
+ return -1;
+ }
+
tr_debug("tr_gssc_open_connection: opening connection to %s:%d", server, port);
- if (0 != gsscon_connect(server, port, gssc->service_name, &(gssc->conn), gssc->gss_ctx))
+ if (0 != gsscon_connect(server, (unsigned int) port, gssc->service_name, &(gssc->conn), gssc->gss_ctx))
return -1;
return 0; /* success */
* @param max_fd maximum number of file descriptors to write
* @return number of file descriptors written into the output array
*/
-nfds_t tr_sock_listen_all(unsigned int port, int *fd_out, nfds_t max_fd)
+nfds_t tr_sock_listen_all(int port, int *fd_out, nfds_t max_fd)
{
int rc = 0;
int conn = -1;
/* Monitoring server instance */
struct mons_instance {
const char *hostname;
- unsigned int port;
+ int mon_port;
TR_GSS_NAMES *authorized_gss_names;
TIDS_INSTANCE *tids;
TRPS_INSTANCE *trps;
/* mons.c */
MONS_INSTANCE *mons_new(TALLOC_CTX *mem_ctx);
-int mons_get_listener(MONS_INSTANCE *mons, MONS_REQ_FUNC *req_handler, MONS_AUTH_FUNC *auth_handler, const char *hostname,
- unsigned int port, void *cookie, int *fd_out, size_t max_fd);
+int mons_get_listener(MONS_INSTANCE *mons,
+ MONS_REQ_FUNC *req_handler,
+ MONS_AUTH_FUNC *auth_handler,
+ const char *hostname,
+ int port,
+ void *cookie,
+ int *fd_out,
+ size_t max_fd);
int mons_accept(MONS_INSTANCE *mons, int listen);
/* monc.c */
MONC_INSTANCE *monc_new(TALLOC_CTX *mem_ctx);
void monc_free(MONC_INSTANCE *monc);
-int monc_open_connection(MONC_INSTANCE *monc, const char *server, unsigned int port);
+int monc_open_connection(MONC_INSTANCE *monc, const char *server, int port);
MON_RESP *monc_send_request(TALLOC_CTX *mem_ctx, MONC_INSTANCE *monc, MON_REQ *req);
#endif //TRUST_ROUTER_MON_REQ_H
TIDS_REQ_FUNC *req_handler;
tids_auth_func *auth_handler;
void *cookie;
- unsigned int tids_port;
+ int tids_port;
TR_NAME *gss_name; /* GSS name client used for authentication */
GArray *pids; /* PIDs of active tids processes */
};
reference they already hold to the TID_REQ.*/
void tid_req_cleanup_json(TID_REQ *, json_t *json);
-int tid_req_add_path(TID_REQ *, const char *this_system, unsigned port);
+int tid_req_add_path(TID_REQ *req, const char *this_system, int port);
TID_SRVR_BLK *tid_srvr_blk_new(TALLOC_CTX *mem_ctx);
void tid_srvr_blk_free(TID_SRVR_BLK *srvr);
typedef struct tr_cfg_internal {
unsigned int max_tree_depth;
- unsigned int tids_port;
- unsigned int trps_port;
- unsigned int monitoring_port;
+ int tids_port;
+ int trps_port;
+ int mons_port;
const char *hostname;
int log_threshold;
int console_threshold;
/* tr_gss_client.c */
TR_GSSC_INSTANCE *tr_gssc_instance_new(TALLOC_CTX *mem_ctx);
void tr_gssc_instance_free(TR_GSSC_INSTANCE *tr_gssc);
-int tr_gssc_open_connection(TR_GSSC_INSTANCE *gssc, const char *server, unsigned int port);
+int tr_gssc_open_connection(TR_GSSC_INSTANCE *gssc, const char *server, int port);
TR_MSG *tr_gssc_exchange_msgs(TALLOC_CTX *mem_ctx, TR_GSSC_INSTANCE *gssc, TR_MSG *req_msg);
#endif //TRUST_ROUTER_TR_GSS_CLIENT_H
#include <poll.h> // for nfds_t
#include <sys/socket.h>
-nfds_t tr_sock_listen_all(unsigned int port, int *fd_out, nfds_t max_fd);
+nfds_t tr_sock_listen_all(int port, int *fd_out, nfds_t max_fd);
int tr_sock_accept(int sock);
#endif //TRUST_ROUTER_TR_SOCKET_H
TRPC_INSTANCE *next;
TR_NAME *gssname;
char *server;
- unsigned int port;
+ int port;
TRP_CONNECTION *conn;
TR_MQ *mq; /* msgs from master to trpc */
};
/* TRP Server Instance Data */
struct trps_instance {
char *hostname;
- unsigned int port;
+ int trps_port;
+ int tids_port; /* used for route advertisements; must agree with our tids configuration */
TRP_AUTH_FUNC auth_handler;
TRPS_MSG_FUNC msg_handler;
void *cookie;
void trp_connection_append(TRP_CONNECTION *conn, TRP_CONNECTION *new);
int trp_connection_auth(TRP_CONNECTION *conn, TRP_AUTH_FUNC auth_callback, void *callback_data);
TRP_CONNECTION *trp_connection_accept(TALLOC_CTX *mem_ctx, int listen, TR_NAME *gss_servicename);
-TRP_RC trp_connection_initiate(TRP_CONNECTION *conn, char *server, unsigned int port);
+TRP_RC trp_connection_initiate(TRP_CONNECTION *conn, char *server, int port);
TRPC_INSTANCE *trpc_new (TALLOC_CTX *mem_ctx);
void trpc_free (TRPC_INSTANCE *trpc);
TR_NAME *trpc_get_gssname(TRPC_INSTANCE *trpc);
void trpc_set_gssname(TRPC_INSTANCE *trpc, TR_NAME *gssname);
unsigned int trpc_get_port(TRPC_INSTANCE *trpc);
-void trpc_set_port(TRPC_INSTANCE *trpc, unsigned int port);
+void trpc_set_port(TRPC_INSTANCE *trpc, int port);
TRP_CONNECTION_STATUS trpc_get_status(TRPC_INSTANCE *trpc);
TR_MQ *trpc_get_mq(TRPC_INSTANCE *trpc);
void trpc_set_mq(TRPC_INSTANCE *trpc, TR_MQ *mq);
TRPS_MSG_FUNC msg_handler,
TRP_AUTH_FUNC auth_handler,
const char *hostname,
- unsigned int port,
+ int port,
void *cookie,
int *fd_out,
size_t max_fd);
char *server;
TR_GSS_NAMES *gss_names;
TR_NAME *servicename;
- unsigned int port;
+ int port;
unsigned int linkcost;
struct timespec last_conn_attempt;
TRP_PEER_CONN_STATUS outgoing_status;
TR_GSS_NAMES *trp_peer_get_gss_names(TRP_PEER *peer);
TR_NAME *trp_peer_get_servicename(TRP_PEER *peer);
TR_NAME *trp_peer_dup_servicename(TRP_PEER *peer);
-unsigned int trp_peer_get_port(TRP_PEER *peer);
-void trp_peer_set_port(TRP_PEER *peer, unsigned int port);
+int trp_peer_get_port(TRP_PEER *peer);
+void trp_peer_set_port(TRP_PEER *peer, int port);
unsigned int trp_peer_get_linkcost(TRP_PEER *peer);
struct timespec *trp_peer_get_last_conn_attempt(TRP_PEER *peer);
void trp_peer_set_last_conn_attempt(TRP_PEER *peer, struct timespec *time);
/* TID Client functions, in tid/tidc.c */
TR_EXPORT TIDC_INSTANCE *tidc_create (void);
-TR_EXPORT int tidc_open_connection (TIDC_INSTANCE *tidc, const char *server, unsigned int port, gss_ctx_id_t *gssctx);
+TR_EXPORT int tidc_open_connection(TIDC_INSTANCE *tidc, const char *server, int port, gss_ctx_id_t *gssctx);
TR_EXPORT int tidc_send_request (TIDC_INSTANCE *tidc, int conn, gss_ctx_id_t gssctx, const char *rp_realm, const char *realm, const char *coi, TIDC_RESP_FUNC *resp_handler, void *cookie);
TR_EXPORT int tidc_fwd_request (TIDC_INSTANCE *tidc, TID_REQ *req, TIDC_RESP_FUNC *resp_handler, void *cookie);
TR_EXPORT DH *tidc_get_dh(TIDC_INSTANCE *);
/* TID Server functions, in tid/tids.c */
TIDS_INSTANCE *tids_new(TALLOC_CTX *mem_ctx);
TR_EXPORT TIDS_INSTANCE *tids_create (void);
-TR_EXPORT int tids_start (TIDS_INSTANCE *tids, TIDS_REQ_FUNC *req_handler,
- tids_auth_func *auth_handler, const char *hostname,
- unsigned int port, void *cookie);
+TR_EXPORT int tids_start(TIDS_INSTANCE *tids, TIDS_REQ_FUNC *req_handler,
+ tids_auth_func *auth_handler, const char *hostname,
+ int port, void *cookie);
TR_EXPORT nfds_t tids_get_listener(TIDS_INSTANCE *tids, TIDS_REQ_FUNC *req_handler,
tids_auth_func *auth_handler, const char *hostname,
- unsigned int port, void *cookie, int *fd_out, size_t max_fd);
+ int port, void *cookie, int *fd_out, size_t max_fd);
TR_EXPORT int tids_accept(TIDS_INSTANCE *tids, int listen);
TR_EXPORT int tids_send_response (TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp);
TR_EXPORT int tids_send_err_response (TIDS_INSTANCE *tids, TID_REQ *req, const char *err_msg);
TR_EXPORT TR_NAME *trp_upd_get_peer(TRP_UPD *upd);
TR_NAME *trp_upd_dup_peer(TRP_UPD *upd);
void trp_upd_set_peer(TRP_UPD *upd, TR_NAME *peer);
-void trp_upd_set_next_hop(TRP_UPD *upd, const char *hostname, unsigned int port);
+void trp_upd_set_next_hop(TRP_UPD *upd, const char *hostname, int port);
void trp_upd_add_to_provenance(TRP_UPD *upd, TR_NAME *name);
/* Functions for TRP_REQ structures */
int monc_open_connection(MONC_INSTANCE *monc,
const char *server,
- unsigned int port)
+ int port)
{
return tr_gssc_open_connection(monc->gssc, server, port);
}
if (mons) {
mons->hostname = NULL;
- mons->port = 0;
+ mons->mon_port = 0;
mons->tids = NULL;
mons->trps = NULL;
mons->req_handler = NULL;
* @param max_fd
* @return
*/
-int mons_get_listener(MONS_INSTANCE *mons, MONS_REQ_FUNC *req_handler, MONS_AUTH_FUNC *auth_handler, const char *hostname,
- unsigned int port, void *cookie, int *fd_out, size_t max_fd)
+int mons_get_listener(MONS_INSTANCE *mons,
+ MONS_REQ_FUNC *req_handler,
+ MONS_AUTH_FUNC *auth_handler,
+ const char *hostname,
+ int port,
+ void *cookie,
+ int *fd_out,
+ size_t max_fd)
{
size_t n_fd=0;
size_t ii=0;
- mons->port = port;
+ mons->mon_port = port;
n_fd = tr_sock_listen_all(port, fd_out, max_fd);
if (n_fd<=0)
tr_err("mons_get_listener: Error opening port %d");
}
int tid_req_add_path(TID_REQ *req,
- const char *this_system, unsigned port)
+ const char *this_system, int port)
{
char *path_element = talloc_asprintf(req, "%s:%u",
this_system, port);
talloc_free(tidc);
}
-int tidc_open_connection (TIDC_INSTANCE *tidc,
- const char *server,
- unsigned int port,
- gss_ctx_id_t *gssctx)
+int tidc_open_connection(TIDC_INSTANCE *tidc,
+ const char *server,
+ int port,
+ gss_ctx_id_t *gssctx)
{
- unsigned int use_port = 0;
+ int use_port = 0;
tidc->gssc->gss_ctx = gssctx;
if (0 == port)
TIDS_REQ_FUNC *req_handler,
tids_auth_func *auth_handler,
const char *hostname,
- unsigned int port,
+ int port,
void *cookie,
int *fd_out,
size_t max_fd)
}
/* Process tids requests forever. Should not return except on error. */
-int tids_start (TIDS_INSTANCE *tids,
- TIDS_REQ_FUNC *req_handler,
- tids_auth_func *auth_handler,
- const char *hostname,
- unsigned int port,
- void *cookie)
+int tids_start(TIDS_INSTANCE *tids,
+ TIDS_REQ_FUNC *req_handler,
+ tids_auth_func *auth_handler,
+ const char *hostname,
+ int port,
+ void *cookie)
{
int fd[TR_MAX_SOCKETS]={0};
nfds_t n_fd=0;
goto cleanup;
}
- if (cfg_mgr->active->internal->monitoring_port == 0) {
+ if (cfg_mgr->active->internal->mons_port == 0) {
tr_notice("tr_mons_event_init: monitoring is disabled, not enabling events or opening sockets");
retval = 0;
goto cleanup;
mons_ev->n_sock_fd = mons_get_listener(mons, tr_mons_req_handler,
tr_mons_auth_handler,
cfg_mgr->active->internal->hostname,
- cfg_mgr->active->internal->monitoring_port,
+ cfg_mgr->active->internal->mons_port,
(void *) cookie, mons_ev->sock_fd,
TR_MAX_SOCKETS);
if (mons_ev->n_sock_fd==0) {
if (-1==(args->fwd_req->conn = tidc_open_connection(tidc,
aaa_hostname,
- (unsigned int) aaa_port, /* we checked, it's > 0 */
- &(args->fwd_req->gssctx)))) {
+ aaa_port,
+ &(args->fwd_req->gssctx)))) {
tr_notice("tr_tids_req_fwd_thread: Error in tidc_open_connection.");
/* tids_send_err_response(tids, orig_req, "Can't open connection to next hop TIDS"); */
/* TODO: encode reason for failure */
/* structure for communicating with option parser */
struct cmdline_args {
char *server;
- unsigned int port;
+ int port;
MON_CMD command;
MON_OPT_TYPE options[MAX_OPTIONS];
unsigned int n_options;
if (errno || (tmp_l < 0) || (tmp_l > 65535)) /* max valid port */
argp_usage(state);
- arguments->port=(unsigned int) tmp_l;
+ arguments->port = (int) tmp_l; /* we already checked the range */
break;
case 2:
struct peer_entry {
char *server;
char *gss_name;
- unsigned int port;
+ int port;
unsigned int linkcost;
};
}
/* Initiate connection */
-TRP_RC trp_connection_initiate(TRP_CONNECTION *conn, char *server, unsigned int port)
+TRP_RC trp_connection_initiate(TRP_CONNECTION *conn, char *server, int port)
{
int err = 0;
int fd=-1;
- unsigned int use_port=0;
+ int use_port=0;
if (0 == port)
use_port = TRP_PORT;
return tr_dup_name(peer->servicename);
}
-unsigned int trp_peer_get_port(TRP_PEER *peer)
+int trp_peer_get_port(TRP_PEER *peer)
{
return peer->port;
}
-void trp_peer_set_port(TRP_PEER *peer, unsigned int port)
+void trp_peer_set_port(TRP_PEER *peer, int port)
{
peer->port=port;
}
}
/* helper for encoding to json */
-static json_t *server_to_json_string(const char *server, unsigned int port)
+static json_t *server_to_json_string(const char *server, int port)
{
char *s = talloc_asprintf(NULL, "%s:%u", server, port);
json_t *jstr = json_string(s);
upd->peer=peer;
}
-void trp_upd_set_next_hop(TRP_UPD *upd, const char *hostname, unsigned int port)
+void trp_upd_set_next_hop(TRP_UPD *upd, const char *hostname, int port)
{
TRP_INFOREC *rec=NULL;
TR_NAME *cpy=NULL;
return trpc->port;
}
-void trpc_set_port(TRPC_INSTANCE *trpc, unsigned int port)
+void trpc_set_port(TRPC_INSTANCE *trpc, int port)
{
trpc->port=port;
}