int32 mesh_transpose(Mesh *mesh, int32 d1, int32 d2)
{
int32 ret = RET_OK;
uint32 n_incident;
uint32 ii;
uint32 *nd2 = 0;
uint32 D = mesh->topology->max_dim;
MeshEntityIterator it2[1], it1[1];
MeshConnectivity *c12 = 0; // d1 -> d2 - to compute
debprintf("transpose %d -> %d\n", d1, d2);
if (d1 >= d2) {
errput("d1 must be smaller than d2 in mesh_transpose()!\n");
ERR_CheckGo(ret);
}
c12 = mesh->topology->conn[IJ(D, d1, d2)];
// Count entities of d2 -> d1.
conn_alloc(c12, mesh->topology->num[d1], 0);
ERR_CheckGo(ret);
nd2 = c12->offsets + 1;
for (mei_init(it2, mesh, d2); mei_go(it2); mei_next(it2)) {
for (mei_init_conn(it1, it2->entity, d1); mei_go(it1); mei_next(it1)) {
nd2[it1->entity->ii]++;
}
}
// c12->offsets now contains counts - make a cumsum to get offsets.
for (ii = 1; ii < c12->num + 1; ii++) {
c12->offsets[ii] += c12->offsets[ii-1];
}
n_incident = c12->offsets[c12->num];
debprintf("transpose n_incident (%d -> %d): %d\n", d1, d2, n_incident);
// Fill in the indices.
conn_alloc(c12, 0, n_incident);
ERR_CheckGo(ret);
for (ii = 0; ii < c12->n_incident; ii++) {
c12->indices[ii] = UINT32_None; // "not set" value.
}
for (mei_init(it2, mesh, d2); mei_go(it2); mei_next(it2)) {
for (mei_init_conn(it1, it2->entity, d1); mei_go(it1); mei_next(it1)) {
conn_set_to_free(c12, it1->entity->ii, it2->entity->ii);
ERR_CheckGo(ret);
}
}
end_label:
return(ret);
}
/**
* Accept an incoming TCP Connection
*
* @param tcp Returned TCP Connection object
* @param ts Corresponding TCP Socket
* @param eh TCP Connection Established handler
* @param rh TCP Connection Receive data handler
* @param ch TCP Connection close handler
* @param arg Handler argument
*
* @return 0 if success, otherwise errorcode
*/
int tcp_accept(struct tcp_conn **tcp, struct tcp_sock *ts, tcp_estab_h *eh,
tcp_recv_h *rh, tcp_close_h *ch, void *arg)
{
struct tcp_conn *tc;
int err;
if (!tcp || !ts || ts->fdc < 0)
return EINVAL;
tc = conn_alloc(eh, rh, ch, arg);
if (!tc)
return ENOMEM;
/* Transfer ownership to TCP connection */
tc->fdc = ts->fdc;
ts->fdc = -1;
err = fd_listen(tc->fdc, FD_READ | FD_WRITE | FD_EXCEPT,
tcp_recv_handler, tc);
if (err) {
DEBUG_WARNING("accept: fd_listen(): %m\n", err);
}
if (err)
mem_deref(tc);
else
*tcp = tc;
return err;
}
int tcp_conn_alloc(struct tcp_conn **tcp, const struct sa *peer,
tcp_estab_h *eh, tcp_recv_h *rh, tcp_close_h *ch,
void *arg)
{
struct tcp_conn *tc;
int err;
if (!tcp || !sa_isset(peer, SA_ALL))
return EINVAL;
tc = conn_alloc(NULL, eh, rh, ch, arg);
if (!tc)
return ENOMEM;
TInetAddr ia(sa_in(peer), sa_port(peer));
err = tc->ctc->Open(ia);
if (err)
goto out;
*tcp = tc;
out:
if (err) {
DEBUG_WARNING("conn_alloc: %J (%s)\n", peer, strerror(err));
mem_deref(tc);
}
return err;
}
static void accept_connection(struct pollfd *pfds, int afd)
{
struct sockaddr_storage from;
socklen_t namesize;
struct pollfd *pfd;
struct connection *conn;
int fd, i;
eprintf("%d\n", afd);
namesize = sizeof(from);
if ((fd = accept(afd, (struct sockaddr *) &from, &namesize)) < 0) {
if (errno != EINTR && errno != EAGAIN) {
log_error("accept(incoming_socket)");
exit(1);
}
return;
}
for (i = 0; i < INCOMING_MAX; i++) {
if (!incoming[i])
break;
}
if (i >= INCOMING_MAX) {
log_error("unable to find incoming slot? %d\n", i);
goto out;
}
conn = conn_alloc();
if (!conn) {
log_error("fail to allocate %s", "conn\n");
goto out;
}
conn->fd = fd;
incoming[i] = conn;
conn_read_pdu(conn);
set_non_blocking(fd);
pfd = &pfds[POLL_INCOMING + i];
pfd->fd = fd;
pfd->events = POLLIN;
pfd->revents = 0;
return;
out:
close(fd);
return;
}
conn_t *conn_open(int fd, uint32_t ip, uint16_t port)
{//分配conn_t和cli_conn_t， 并挂接起来
int res = 0;
conn_t *c;
if( (c = conn_alloc()) == NULL ){//这个连接其实是个中间搭桥的连接。
log(g_log, "conn alloc error\n");
return NULL;
}
if( (res = cli_conn_open(c, fd, ip, port)) < 0 ){//将c跟当前的fd连接起来，建立一个客户端连接结构
log(g_log, "cli conn open error\n");
conn_release(c);
return NULL;
}
return c;
}
static bool send_handler(int *err, struct sa *dst, struct mbuf *mb, void *arg)
{
struct tls_sock *ts = arg;
struct tls_conn *tc;
int r;
tc = tls_udp_conn(ts, dst);
if (!tc) {
/* No connection found, assuming Client role */
tc = conn_alloc(ts, dst);
if (!tc) {
*err = ENOMEM;
return true;
}
SSL_set_connect_state(tc->ssl);
check_timer(tc);
}
r = SSL_write(tc->ssl, mbuf_buf(mb), (int)mbuf_get_left(mb));
if (r < 0) {
switch (SSL_get_error(tc->ssl, r)) {
case SSL_ERROR_WANT_READ:
break;
default:
DEBUG_WARNING("SSL_write: %d\n",
SSL_get_error(tc->ssl, r));
*err = EPROTO;
return true;
}
}
return true;
}
int tcp_accept(struct tcp_conn **tcp, struct tcp_sock *ts, tcp_estab_h *eh,
tcp_recv_h *rh, tcp_close_h *ch, void *arg)
{
struct tcp_conn *tc;
if (!tcp || !ts)
return EINVAL;
DEBUG_INFO("tcp_accept() ts=%p\n", ts);
tc = conn_alloc(ts->ctc, eh, rh, ch, arg);
if (!tc)
return ENOMEM;
/* Transfer ownership to TCP connection */
ts->ctc->tc = tc;
ts->ctc = NULL;
tc->ctc->StartReceiving();
*tcp = tc;
return 0;
}
int32 mesh_intersect(Mesh *mesh, int32 d1, int32 d2, int32 d3)
{
int32 ret = RET_OK;
uint32 D = mesh->topology->max_dim;
uint32 n_incident, ii;
uint32 *nd2 = 0;
char *mask = 0;
MeshEntityIterator it1[1], it2[1], it3[1];
Indices ei1[1], ei2[1];
MeshConnectivity *c12 = 0; // d1 -> d2 - to compute
MeshConnectivity *c10 = 0; // d1 -> 0 - known
MeshConnectivity *c20 = 0; // d2 -> 0 - known
debprintf("intersect %d -> %d (%d)\n", d1, d2, d3);
if (d1 < d2) {
errput("d1 must be greater or equal to d2 in mesh_intersect()!\n");
ERR_CheckGo(ret);
}
c12 = mesh->topology->conn[IJ(D, d1, d2)];
if (d1 > d2) {
c10 = mesh->topology->conn[IJ(D, d1, 0)];
c20 = mesh->topology->conn[IJ(D, d2, 0)];
}
mask = alloc_mem(char, mesh->topology->num[d2]);
// Count entities of d2 -> d1.
conn_alloc(c12, mesh->topology->num[d1], 0);
ERR_CheckGo(ret);
nd2 = c12->offsets + 1;
for (mei_init(it1, mesh, d1); mei_go(it1); mei_next(it1)) {
// Clear mask for it1 incident entities of dimension d2.
for (mei_init_conn(it3, it1->entity, d3); mei_go(it3); mei_next(it3)) {
for (mei_init_conn(it2, it3->entity, d2); mei_go(it2); mei_next(it2)) {
mask[it2->entity->ii] = 0;
}
}
for (mei_init_conn(it3, it1->entity, d3); mei_go(it3); mei_next(it3)) {
for (mei_init_conn(it2, it3->entity, d2); mei_go(it2); mei_next(it2)) {
if (mask[it2->entity->ii]) continue;
mask[it2->entity->ii] = 1;
if (d1 == d2) {
if (it1->entity->ii != it2->entity->ii) {
nd2[it1->entity->ii]++;
}
} else {
// Get incident vertices.
me_get_incident2(it1->entity, ei1, c10);
me_get_incident2(it2->entity, ei2, c20);
if (contains(ei1, ei2)) {
nd2[it1->entity->ii]++;
}
}
}
}
}
// c12->offsets now contains counts - make a cumsum to get offsets.
for (ii = 1; ii < c12->num + 1; ii++) {
c12->offsets[ii] += c12->offsets[ii-1];
}
n_incident = c12->offsets[c12->num];
debprintf("intersect n_incident (%d -> %d): %d\n", d1, d2, n_incident);
// Fill in the indices.
conn_alloc(c12, 0, n_incident);
ERR_CheckGo(ret);
for (ii = 0; ii < c12->n_incident; ii++) {
c12->indices[ii] = UINT32_None; // "not set" value.
}
for (mei_init(it1, mesh, d1); mei_go(it1); mei_next(it1)) {
// Clear mask for it1 incident entities of dimension d2.
for (mei_init_conn(it3, it1->entity, d3); mei_go(it3); mei_next(it3)) {
for (mei_init_conn(it2, it3->entity, d2); mei_go(it2); mei_next(it2)) {
mask[it2->entity->ii] = 0;
}
}
for (mei_init_conn(it3, it1->entity, d3); mei_go(it3); mei_next(it3)) {
for (mei_init_conn(it2, it3->entity, d2); mei_go(it2); mei_next(it2)) {
if (mask[it2->entity->ii]) continue;
mask[it2->entity->ii] = 1;
if (d1 == d2) {
if (it1->entity->ii != it2->entity->ii) {
conn_set_to_free(c12, it1->entity->ii, it2->entity->ii);
ERR_CheckGo(ret);
}
} else {
// Get incident vertices.
me_get_incident2(it1->entity, ei1, c10);
me_get_incident2(it2->entity, ei2, c20);
if (contains(ei1, ei2)) {
conn_set_to_free(c12, it1->entity->ii, it2->entity->ii);
ERR_CheckGo(ret);
}
}
}
}
}
end_label:
free_mem(mask);
return(ret);
}
int32 mesh_build(Mesh *mesh, int32 dim)
{
int32 ret = RET_OK;
uint32 n_incident, n_v_max, n_loc;
uint32 ii, ic, id, found;
uint32 D = mesh->topology->max_dim;
uint32 facet[4]; // Max. space for single facet.
uint32 *oris = 0;
uint32 loc_oris[12];
uint32 *nDd = 0;
uint32 *ptr1 = 0, *ptr2 = 0;
uint32 *cell_types = mesh->topology->cell_types;
Indices cell_vertices[1];
MeshEntityIterator it0[1], it1[1], it2[1];
MeshConnectivity *cD0 = 0; // D -> 0 - known
MeshConnectivity *cDd = 0; // D -> d - to compute
MeshConnectivity *cd0 = 0; // d -> 0 - to compute
MeshConnectivity **locs = 0;
MeshConnectivity *loc = 0;
MeshConnectivity sloc[1]; // Local connectivity with sorted global vertices.
MeshConnectivity gloc[1]; // Local connectivity with global vertices.
debprintf("build %d\n", dim);
if (!mesh->topology->conn[IJ(D, D, D)]->num) {
mesh_setup_connectivity(mesh, D, D);
}
cD0 = mesh->topology->conn[IJ(D, D, 0)];
cDd = mesh->topology->conn[IJ(D, D, dim)];
cd0 = mesh->topology->conn[IJ(D, dim, 0)];
locs = (dim == 1) ? mesh->entities->edges : mesh->entities->faces;
// Max. number of vertices in facets.
n_v_max = (dim == 1) ? 2 : 4;
// Count entities of D -> d.
conn_alloc(cDd, mesh->topology->num[D], 0);
ERR_CheckGo(ret);
nDd = cDd->offsets + 1;
for (mei_init(it0, mesh, D); mei_go(it0); mei_next(it0)) {
loc = locs[cell_types[it0->it]];
nDd[it0->it] = loc->num;
}
// cDd->offsets now contains counts - make a cumsum to get offsets.
for (ii = 1; ii < cDd->num + 1; ii++) {
cDd->offsets[ii] += cDd->offsets[ii-1];
}
n_incident = cDd->offsets[cDd->num];
debprintf("build n_incident (%d -> %d): %d\n", D, dim, n_incident);
// Cell-local orientations w.r.t. D -> d.
oris = alloc_mem(uint32, n_incident);
if (dim == 2) {
free_mem(mesh->topology->face_oris);
mesh->topology->face_oris = oris;
} else {
free_mem(mesh->topology->edge_oris);
mesh->topology->edge_oris = oris;
}
// Allocate D -> d indices.
conn_alloc(cDd, 0, n_incident);
ERR_CheckGo(ret);
for (ii = 0; ii < cDd->n_incident; ii++) {
cDd->indices[ii] = UINT32_None; // "not set" value.
}
// Allocate maximal buffers for d -> 0 arrays.
conn_alloc(cd0, n_incident, n_incident * n_v_max);
debprintf("build max. n_incident_vertex: %d\n", n_incident * n_v_max);
// Allocate maximal buffers for local connectivity with sorted global
// vertices. Counts have to be set to zero to avoid spurious calls to
// conn_free()!
sloc->num = sloc->n_incident = 0;
conn_alloc(sloc, 12, n_v_max * 12);
gloc->num = gloc->n_incident = 0;
conn_alloc(gloc, 12, n_v_max * 12);
id = 0;
for (mei_init(it0, mesh, D); mei_go(it0); mei_next(it0)) {
// Get vertex sets for local entities of current cell.
loc = locs[cell_types[it0->it]];
me_get_incident2(it0->entity, cell_vertices, cD0);
get_local_connectivity(gloc, cell_vertices, loc);
conn_set_from(sloc, gloc);
sort_local_connectivity(sloc, loc_oris, loc->num);
// Iterate over entities in the vertex sets.
for (ii = 0; ii < loc->num; ii++) {
// ii points to a vertex set in sloc/gloc.
n_loc = sloc->offsets[ii+1] - sloc->offsets[ii];
// Try to find entity in cells visited previously.
for (mei_init_conn(it1, it0->entity, D); mei_go(it1); mei_next(it1)) {
if (it1->entity->ii >= it0->entity->ii) continue;
// Iterate over facets of visited cells.
for (mei_init_conn(it2, it1->entity, dim); mei_go(it2); mei_next(it2)) {
ptr1 = cd0->indices + cd0->offsets[it2->entity->ii];
uint32_sort234_copy(facet, ptr1, n_loc);
ptr2 = sloc->indices + sloc->offsets[ii];
found = 1;
for (ic = 0; ic < n_loc; ic++) {
if (facet[ic] != ptr2[ic]) {
found = 0;
break;
}
}
if (found) {
// Assign existing entity to D -> d.
conn_set_to_free(cDd, it0->entity->ii, it2->entity->ii);
goto found_label;
}
}
}
// Entity not found - create new.
// Add it as 'id' to D -> d.
conn_set_to_free(cDd, it0->entity->ii, id);
// Add vertices in gloc to d -> 0.
cd0->offsets[id+1] = cd0->offsets[id] + n_loc;
ptr1 = cd0->indices + cd0->offsets[id];
ptr2 = gloc->indices + gloc->offsets[ii];
for (ic = 0; ic < n_loc; ic++) {
ptr1[ic] = ptr2[ic];
}
// Increment entity counter.
id++;
found_label:
// Store entity orientation key to position of the last used item in cDd.
ptr1 = cDd->offsets + it0->entity->ii;
ic = ptr1[1] - 1;
while (ic >= ptr1[0]) {
if (cDd->indices[ic] != UINT32_None) { // Not found & free slot.
break;
}
ic--;
}
// printf("%d << %d, %d\n", ic, ii, loc_oris[ii]);
oris[ic] = loc_oris[ii];
}
}
debprintf("build n_unique: %d, n_incident (%d -> 0): %d\n",
id, dim, cd0->offsets[id]);
// Update entity count in topology.
mesh->topology->num[dim] = id;
// Strip d -> 0.
conn_resize(cd0, id, cd0->offsets[id]);
end_label:
conn_free(sloc);
conn_free(gloc);
return(ret);
}
/**
* Get connection info for a given process id.
*
* For logical NIs the connection is contained in the rank table.
* For physical NIs the connection is held in a binary tree using
* the ID as a sorting value.
*
* For physical NIs if this is the first time we are sending a message
* to this process create a new conn_t. For logical NIs the conn_t
* structs are all allocated when the rank table is loaded.
*
* @param[in] ni the NI from which to get the connection
* @param[in] id the process ID to lookup
*
* @return the conn_t and takes a reference on it
*/
conn_t *get_conn(ni_t *ni, ptl_process_t id)
{
conn_t *conn;
void **ret;
if (ni->options & PTL_NI_LOGICAL) {
if (unlikely(id.rank >= ni->logical.map_size)) {
ptl_warn("Invalid rank (%d >= %d)\n", id.rank,
ni->logical.map_size);
return NULL;
}
conn = ni->logical.rank_table[id.rank].connect;
conn_get(conn);
} else {
conn_t conn_search;
PTL_FASTLOCK_LOCK(&ni->physical.lock);
/* lookup in binary tree */
conn_search.id = id;
ret = tfind(&conn_search, &ni->physical.tree, compare_conn_id);
if (ret) {
conn = *ret;
conn_get(conn);
} else {
/* Not found. Allocate and insert. */
if (conn_alloc(ni, &conn)) {
PTL_FASTLOCK_UNLOCK(&ni->physical.lock);
WARN();
return NULL;
}
#if IS_PPE || WITH_TRANSPORT_SHMEM
//need to connect local processes over shared memory
if (conn->id.phys.nid == ni->iface->id.phys.nid) {
if (get_param(PTL_ENABLE_MEM)) {
#if IS_PPE
conn->transport = transport_mem;
#elif WITH_TRANSPORT_SHMEM
conn->transport = transport_shmem;
#endif
conn->state = CONN_STATE_CONNECTED;
}
}
#endif
conn->id = id;
/* Get the IP address from the NID. */
conn->sin.sin_family = AF_INET;
conn->sin.sin_addr.s_addr = nid_to_addr(id.phys.nid);
conn->sin.sin_port = pid_to_port(id.phys.pid);
/* insert new conn into binary tree */
ret = tsearch(conn, &ni->physical.tree, compare_conn_id);
if (!ret) {
WARN();
conn_put(conn);
conn = NULL;
} else {
conn_get(conn);
}
}
PTL_FASTLOCK_UNLOCK(&ni->physical.lock);
}
return conn;
}
/**
* Allocate a TCP Connection
*
* @param tcp Returned TCP Connection object
* @param peer Network address of peer
* @param eh TCP Connection Established handler
* @param rh TCP Connection Receive data handler
* @param ch TCP Connection close handler
* @param arg Handler argument
*
* @return 0 if success, otherwise errorcode
*/
int tcp_conn_alloc(struct tcp_conn **tcp,
const struct sa *peer, tcp_estab_h *eh,
tcp_recv_h *rh, tcp_close_h *ch, void *arg)
{
struct tcp_conn *tc;
struct addrinfo hints, *res = NULL, *r;
char addr[64];
char serv[NI_MAXSERV] = "0";
int error, err;
if (!tcp || !sa_isset(peer, SA_ALL))
return EINVAL;
tc = conn_alloc(eh, rh, ch, arg);
if (!tc)
return ENOMEM;
memset(&hints, 0, sizeof(hints));
/* set-up hints structure */
hints.ai_family = PF_UNSPEC;
hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
(void)re_snprintf(addr, sizeof(addr), "%H",
sa_print_addr, peer);
(void)re_snprintf(serv, sizeof(serv), "%u", sa_port(peer));
error = getaddrinfo(addr, serv, &hints, &res);
if (error) {
DEBUG_WARNING("connect: getaddrinfo(): (%s)\n",
gai_strerror(error));
err = EADDRNOTAVAIL;
goto out;
}
err = EINVAL;
for (r = res; r; r = r->ai_next) {
tc->fdc = SOK_CAST socket(r->ai_family, SOCK_STREAM,
IPPROTO_TCP);
if (tc->fdc < 0) {
err = errno;
continue;
}
err = net_sockopt_blocking_set(tc->fdc, false);
if (err) {
DEBUG_WARNING("connect: nonblock set: %m\n", err);
(void)close(tc->fdc);
tc->fdc = -1;
continue;
}
tcp_sockopt_set(tc->fdc);
err = 0;
break;
}
freeaddrinfo(res);
out:
if (err)
mem_deref(tc);
else
*tcp = tc;
return err;
}
static bool recv_handler(struct sa *src, struct mbuf *mb, void *arg)
{
struct tls_sock *ts = arg;
struct tls_conn *tc;
int r;
tc = tls_udp_conn(ts, src);
if (!tc) {
/* No connection found, assuming Server role */
tc = conn_alloc(ts, src);
if (!tc)
return true;
SSL_set_verify(tc->ssl, 0, 0);
SSL_set_accept_state(tc->ssl);
}
/* feed SSL data to the BIO */
r = BIO_write(tc->sbio_in, mbuf_buf(mb), (int)mbuf_get_left(mb));
if (r <= 0)
return true;
check_timer(tc);
mbuf_set_pos(mb, 0);
for (;;) {
int n;
if (mbuf_get_space(mb) < 4096) {
if (mbuf_resize(mb, mb->size + 8192))
return true;
}
n = SSL_read(tc->ssl, mbuf_buf(mb), (int)mbuf_get_space(mb));
if (n < 0) {
const int ssl_err = SSL_get_error(tc->ssl, n);
switch (ssl_err) {
case SSL_ERROR_WANT_READ:
break;
default:
return true;
}
break;
}
else if (n == 0)
break;
mb->pos += n;
}
if (!mb->pos)
return true;
mbuf_set_end(mb, mb->pos);
mbuf_set_pos(mb, 0);
return false;
}
int rdt_connect(struct in_addr dst, int scid, int dcid)
{
int n, fd;
pid_t pid;
struct sockaddr_un un;
struct in_addr src;
struct conn_info conn_info;
if (signal(SIGINT, sig_hand) == SIG_ERR ||
signal(SIGHUP, sig_hand) == SIG_ERR ||
signal(SIGQUIT, sig_hand) == SIG_ERR)
{
err_sys("signal() error");
}
src = get_addr(dst);
pid = getpid();
/* allocate share area for send
* and recv process.
*/
conn_alloc();
conn_info.cact = ACTIVE;
conn_info.pid = pid;
conn_info.src = conn_user->src = src;
conn_info.dst = conn_user->dst = dst;
conn_info.scid = conn_user->scid = scid;
conn_info.dcid = conn_user->dcid = dcid;
conn_user->sndfd = make_fifo(pid, "snd");
conn_user->rcvfd = make_fifo(pid, "rcv");
conn_user->sfd = make_sock();
conn_user->seq = conn_user->ack = 0;
if (!mtu) {
if (dev[0] == 0 && !get_dev(src, dev))
err_quit("can't get dev name");
mtu = get_mtu(dev);
}
n = min(mtu, 1500);
conn_user->mss = n;
if ((conn_user->sndpkt = malloc(n)) == NULL)
err_sys("malloc() sndpkt error");
if ((conn_user->rcvpkt = malloc(n)) == NULL)
err_sys("malloc() rcvpkt error");
if ((fd = ux_cli(RDT_UX_SOCK, &un)) < 0)
err_sys("ux_cli() error");
n = sizeof(struct conn_info);
if (sendto(fd, &conn_info, n, 0, (struct sockaddr *)&un,
sizeof(struct sockaddr_un)) != n)
{
err_sys("sendto() error");
}
get_pkt(conn_user->sndfd, &conn_info, NULL, 0);
conn_user->scid = conn_info.scid;
if (rexmt_pkt(conn_user, RDT_REQ, NULL, 0) < 0)
err_sys("rexmt_pkt() error");
fprintf(stderr, "rdt_connect() succeed\n");
pkt_debug((struct rdthdr *)conn_user->sndpkt);
return(0);
}
struct connection *
make_conn_block (DN name, struct PSAPaddr *addr, int conn_ctx)
{
struct connection * cn;
struct TSAPaddr *ta;
struct NSAPaddr *na;
extern struct PSAPaddr * mydsaaddr;
int x;
char onnet = FALSE;
/*
* Set up a new connection block and add it to the list.
*/
if(dn_cmp(name, mydsadn) == 0) {
LLOG(log_dsap, LLOG_FATAL, ("Trying to connect to self :-)"));
return(NULLCONN);
}
if (! addr) {
pslog (log_dsap,LLOG_EXCEPTIONS,"Invalid (accesspoint) reference",
(IFP)dn_print,(caddr_t)name);
return(NULLCONN);
}
/* see if on the appropriate net */
ta = & (addr->pa_addr.sa_addr);
/* compare ta and ts_communities to see if they have a network in common */
for (na=ta->ta_addrs , x = ta->ta_naddr - 1 ;
x >= 0;
na++, x-- ) {
int *ip;
for (ip = ts_communities; *ip; ip++) {
if (na->na_community == *ip) {
onnet = TRUE;
break;
}
}
}
if (! onnet) {
LLOG(log_dsap, LLOG_TRACE, ("make_conn_block - no network in common"));
return(NULLCONN);
}
if((cn = conn_alloc()) == NULLCONN) {
LLOG(log_dsap, LLOG_EXCEPTIONS, ("make_conn_block - conn_alloc() out of memory"));
return(NULLCONN);
}
cn->cn_state = CN_WAITING;
cn->cn_ctx = conn_ctx;
cn->cn_initiator = TRUE;
make_dsa_bind_arg(&(cn->cn_connect.cc_req));
cn->cn_dn = dn_cpy(name);
DLOG (log_dsap,LLOG_TRACE,( "Before psap_dup: %s", paddr2str(addr,NULLNA)));
psap_dup(&(cn->cn_addr), addr);
DLOG (log_dsap,LLOG_TRACE,( "After psap_dup: %s", paddr2str(&(cn->cn_addr),NULLNA)));
return(cn);
}
