Lines Matching defs:user
68 set_state(struct ccuser *user, enum user_state ns)
70 if (user->state != ns) {
71 if (user->cc->log & CCLOG_USER_STATE)
72 cc_user_log(user, "%s -> %s",
73 stab[user->state], stab[ns]);
74 user->state = ns;
79 cc_user_send(struct ccuser *user, u_int op, void *arg, size_t len)
81 user->cc->funcs->send_user(user, user->uarg, op, arg, len);
85 cc_user_ok(struct ccuser *user, u_int data, void *arg, size_t len)
87 user->cc->funcs->respond_user(user, user->uarg,
92 cc_user_err(struct ccuser *user, int err)
94 user->cc->funcs->respond_user(user, user->uarg,
109 struct ccuser *user;
111 user = CCZALLOC(sizeof(*user));
112 if (user == NULL)
115 user->cc = cc;
116 user->state = USER_NULL;
117 user->uarg = uarg;
118 strncpy(user->name, name, sizeof(user->name));
119 user->name[sizeof(user->name) - 1] = '\0';
120 TAILQ_INIT(&user->connq);
121 LIST_INSERT_HEAD(&cc->user_list, user, node_link);
123 if (user->cc->log & CCLOG_USER_INST)
124 cc_user_log(user, "created with name '%s'", name);
126 return (user);
130 * Reset a user instance
133 cc_user_reset(struct ccuser *user)
136 CCASSERT(TAILQ_EMPTY(&user->connq), ("connq not empty"));
138 if (user->sap != NULL) {
139 CCFREE(user->sap);
140 user->sap = NULL;
143 if (user->accepted != NULL) {
144 user->accepted->acceptor = NULL;
145 user->accepted = NULL;
147 user->config = USER_P2P;
148 user->queue_act = 0;
149 user->queue_max = 0;
150 user->aborted = 0;
152 set_state(user, USER_NULL);
154 cc_user_sig_flush(user);
158 cc_user_abort(struct ccuser *user, const struct uni_ie_cause *cause)
170 * First bring user into a state that the connections
173 set_state(user, USER_NULL);
174 if (!user->aborted) {
175 if ((conn = TAILQ_FIRST(&user->connq)) != NULL) {
185 while ((conn = TAILQ_FIRST(&user->connq)) != NULL) {
191 cc_user_reset(user);
195 * Application has closed this endpoint. Clean up all user resources and
199 cc_user_destroy(struct ccuser *user)
202 if (user->cc->log & CCLOG_USER_INST)
203 cc_user_log(user, "destroy '%s'", user->name);
205 cc_user_abort(user, NULL);
207 if (user->sap != NULL)
208 CCFREE(user->sap);
210 cc_user_sig_flush(user);
212 LIST_REMOVE(user, node_link);
213 CCFREE(user);
238 * Check if the user's SAP (given he is in the right state) and
242 check_overlap(struct ccuser *user, struct uni_sap *sap)
244 return ((user->state == USER_IN_PREPARING ||
245 user->state == USER_IN_WAITING) &&
246 unisve_overlap_sap(user->sap, sap));
250 * Send arrival notification to user
253 do_arrival(struct ccuser *user)
257 user->aborted = 0;
258 if ((conn = TAILQ_FIRST(&user->connq)) != NULL) {
259 set_state(user, USER_IN_ARRIVED);
260 cc_user_send(user, ATMOP_ARRIVAL_OF_INCOMING_CALL, NULL, 0);
275 cc_query_check(struct ccuser *user)
278 switch (user->state) {
283 return (TAILQ_FIRST(&user->connq));
291 if (user->accepted != NULL &&
292 user->accepted->state == CONN_IN_WAIT_ACCEPT_OK)
293 return (user->accepted);
305 cc_attr_query(struct ccuser *user, struct ccconn *conn,
399 cc_user_err(user, ATMERR_BAD_ATTR);
528 cc_user_ok(user, ATMRESP_ATTRS, val, total);
537 cc_set_check(struct ccuser *user)
539 switch(user->state) {
543 return (TAILQ_FIRST(&user->connq));
554 cc_attr_set(struct ccuser *user, struct ccconn *conn, uint32_t *attr,
665 cc_user_err(user, ATMERR_BAD_ATTR);
674 cc_user_err(user, ATMERR_BAD_ARGS);
793 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
797 cc_user_err(user, ATMERR_BAD_VALUE);
801 cc_user_err(user, ATMERR_RDONLY);
835 * Signal from user - map this to our internal signals and queue
839 cc_user_signal(struct ccuser *user, enum atmop sig, struct uni_msg *msg)
844 if (user->cc->log & CCLOG_USER_SIG)
845 cc_user_log(user, "signal %s to user", op_names[sig]);
855 err = cc_user_sig_msg(user, USER_SIG_ABORT_CONNECTION, msg);
861 err = cc_user_sig_msg(user, USER_SIG_ACCEPT_INCOMING, msg);
867 err = cc_user_sig_msg(user, USER_SIG_ADD_PARTY, msg);
873 err = cc_user_sig_msg(user, USER_SIG_CALL_RELEASE, msg);
879 err = cc_user_sig_msg(user, USER_SIG_CONNECT_OUTGOING, msg);
885 err = cc_user_sig_msg(user, USER_SIG_DROP_PARTY, msg);
891 err = cc_user_sig_msg(user, USER_SIG_GET_LOCAL_PORT_INFO, msg);
897 err = cc_user_sig_msg(user, USER_SIG_PREPARE_INCOMING, msg);
904 err = cc_user_sig(user, USER_SIG_PREPARE_OUTGOING, NULL, 0);
910 err = cc_user_sig_msg(user, USER_SIG_QUERY_ATTR, msg);
916 err = cc_user_sig_msg(user, USER_SIG_REJECT_INCOMING, msg);
922 err = cc_user_sig_msg(user, USER_SIG_SET_ATTR, msg);
929 err = cc_user_sig(user, USER_SIG_WAIT_ON_INCOMING, NULL, 0);
939 err = cc_user_sig_msg(user, USER_SIG_QUERY_ATTR_X, msg);
945 err = cc_user_sig_msg(user, USER_SIG_SET_ATTR_X, msg);
952 err = cc_user_sig(user, USER_SIG_QUERY_STATE, NULL, 0);
963 if (user->cc->log & CCLOG_USER_SIG)
964 cc_user_log(user, "bad signal %u", sig);
965 cc_user_err(user, ATMERR_BAD_OP);
973 if (user->cc->log & CCLOG_USER_SIG)
974 cc_user_log(user, "signal %s had bad len=%zu",
976 cc_user_err(user, ATMERR_BAD_ARGS);
982 * Send active signal to user
985 cc_user_active(struct ccuser *user)
987 struct ccconn *conn = TAILQ_FIRST(&user->connq);
989 set_state(user, USER_ACTIVE);
993 user->config = USER_P2P;
998 cc_user_send(user, ATMOP_P2P_CALL_ACTIVE, act, sizeof(*act));
1003 user->config = USER_ROOT;
1008 cc_user_send(user, ATMOP_P2MP_CALL_ACTIVE, act, sizeof(*act));
1014 * Handle a signal to this user
1017 cc_user_sig_handle(struct ccuser *user, enum user_sig sig,
1021 if (user->cc->log & CCLOG_USER_SIG)
1022 cc_user_log(user, "signal %s to user state %s",
1023 cc_user_sigtab[sig], stab[user->state]);
1034 * connection. It is assigned, when the user issues the call
1039 if (user->state != USER_NULL) {
1040 cc_user_err(user, ATMERR_BAD_STATE);
1043 conn = cc_conn_create(user->cc);
1045 cc_user_err(user, ATMERR_NOMEM);
1048 set_state(user, USER_OUT_PREPARING);
1051 cc_connect_to_user(conn, user);
1053 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1068 struct ccdata *priv = user->cc;
1071 struct ccconn *conn = TAILQ_FIRST(&user->connq);
1073 if (user->state != USER_OUT_PREPARING) {
1075 cc_user_err(user, ATMERR_BAD_STATE);
1080 cc_user_err(user, ATMERR_BAD_ARGS);
1090 cc_user_err(user, ATMERR_BAD_PORT);
1115 set_state(user, USER_OUT_WAIT_OK);
1123 switch (user->state) {
1126 set_state(user, USER_OUT_PREPARING);
1127 cc_user_err(user, arg2);
1134 conn = TAILQ_FIRST(&user->connq);
1140 cc_user_reset(user);
1141 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1152 switch (user->state) {
1155 set_state(user, USER_OUT_WAIT_CONF);
1156 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1160 set_state(user, USER_REL_WAIT_SCONF);
1173 switch (user->state) {
1176 cc_user_active(user);
1181 set_state(user, USER_REL_WAIT_CONF);
1182 cc_conn_sig(TAILQ_FIRST(&user->connq),
1199 if (user->state != USER_NULL) {
1201 cc_user_err(user, ATMERR_BAD_STATE);
1210 cc_user_err(user, ATMERR_BAD_SAP);
1218 LIST_FOREACH(ptr, &user->cc->user_list, node_link) {
1221 cc_user_err(user, ATMERR_OVERLAP);
1229 user->sap = CCZALLOC(sizeof(struct uni_sap));
1230 if (user->sap == NULL) {
1232 cc_user_err(user, ATMERR_NOMEM);
1235 *user->sap = prep->sap;
1236 user->queue_max = prep->queue_size;
1237 user->queue_act = 0;
1240 set_state(user, USER_IN_PREPARING);
1241 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1248 if (user->state != USER_IN_PREPARING) {
1249 cc_user_err(user, ATMERR_BAD_STATE);
1253 set_state(user, USER_IN_WAITING);
1254 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1263 switch (user->state) {
1266 do_arrival(user);
1283 * User rejects call. This is done on the OLD user
1289 struct ccconn *conn = TAILQ_FIRST(&user->connq);
1291 if (user->state != USER_IN_ARRIVED) {
1293 cc_user_err(user, ATMERR_BAD_STATE);
1296 if (user->aborted) {
1298 * to the user and lock whether there is another
1301 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1303 set_state(user, USER_IN_WAITING);
1304 do_arrival(user);
1311 set_state(user, USER_IN_WAIT_REJ);
1319 if (user->state != USER_IN_WAIT_REJ)
1321 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1323 set_state(user, USER_IN_WAITING);
1324 do_arrival(user);
1329 if (user->state != USER_IN_WAIT_REJ)
1331 cc_user_err(user, arg2);
1334 set_state(user, USER_IN_ARRIVED);
1336 set_state(user, USER_IN_WAITING);
1337 do_arrival(user);
1345 * User accepts call. This is done on the OLD user (i.e. the one
1354 if (user->state != USER_IN_ARRIVED) {
1356 cc_user_err(user, ATMERR_BAD_STATE);
1359 if (user->aborted) {
1361 * to the user and lock whether there is another
1364 cc_user_err(user, ATMERR_PREVIOUSLY_ABORTED);
1366 set_state(user, USER_IN_WAITING);
1367 do_arrival(user);
1372 LIST_FOREACH(newep, &user->cc->user_list, node_link)
1378 cc_user_err(user, ATMERR_BAD_ENDPOINT);
1383 cc_user_err(user, ATMERR_BAD_STATE);
1387 set_state(user, USER_IN_WAIT_ACC);
1388 cc_conn_sig(TAILQ_FIRST(&user->connq), CONN_SIG_ACCEPT, newep);
1395 if (user->state != USER_IN_WAIT_ACC)
1397 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1399 set_state(user, USER_IN_WAITING);
1400 do_arrival(user);
1405 if (user->state != USER_IN_WAIT_ACC)
1407 cc_user_err(user, arg2);
1411 set_state(user, USER_IN_ARRIVED);
1413 set_state(user, USER_IN_WAITING);
1414 do_arrival(user);
1420 if (user->state != USER_NULL)
1422 set_state(user, USER_IN_ACCEPTING);
1428 struct ccconn *conn = TAILQ_FIRST(&user->connq);
1430 if (user->state != USER_IN_ACCEPTING)
1433 user->state = USER_ACTIVE;
1437 user->config = USER_P2P;
1442 cc_user_send(user, ATMOP_P2P_CALL_ACTIVE,
1448 user->config = USER_LEAF;
1453 cc_user_send(user, ATMOP_P2MP_CALL_ACTIVE,
1468 conn = TAILQ_FIRST(&user->connq);
1469 switch (user->state) {
1475 set_state(user, USER_REL_WAIT_CONN);
1482 set_state(user, USER_REL_WAIT_SCONF);
1488 set_state(user, USER_REL_WAIT_SCOMP);
1495 set_state(user, USER_REL_WAIT);
1501 cc_user_err(user, ATMERR_BAD_STATE);
1513 switch (user->state) {
1517 cc_user_reset(user);
1524 cc_user_reset(user);
1525 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1529 cc_user_reset(user);
1539 memcpy(ind->cause, user->cause, sizeof(ind->cause));
1540 cc_user_send(user, ATMOP_CALL_RELEASE, ind, sizeof(*ind));
1547 switch (user->state) {
1550 set_state(user, USER_ACTIVE);
1551 cc_user_err(user, ATM_MKUNIERR(arg2));
1555 cc_user_err(user, ATM_MKUNIERR(arg2));
1556 cc_user_active(user);
1560 set_state(user, USER_IN_ACCEPTING);
1561 cc_user_err(user, ATM_MKUNIERR(arg2));
1577 if (user->state != USER_ACTIVE || user->config != USER_ROOT) {
1579 cc_user_err(user, ATMERR_BAD_STATE);
1585 cc_user_err(user, ATMERR_BAD_LEAF_IDENT);
1589 conn = TAILQ_FIRST(&user->connq);
1601 if (user->state != USER_ACTIVE)
1603 cc_user_err(user, arg2);
1608 if (user->state != USER_ACTIVE)
1610 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1619 if (user->state != USER_ACTIVE)
1627 cc_user_send(user, ATMOP_ADD_PARTY_SUCCESS,
1640 if (user->state != USER_ACTIVE)
1648 reject->cause = user->cause[0];
1649 cc_user_send(user, ATMOP_ADD_PARTY_REJECT,
1664 if (user->state != USER_ACTIVE || user->config != USER_ROOT) {
1666 cc_user_err(user, ATMERR_BAD_STATE);
1672 cc_user_err(user, ATMERR_BAD_LEAF_IDENT);
1676 conn = TAILQ_FIRST(&user->connq);
1689 if (user->state != USER_ACTIVE)
1691 cc_user_err(user, arg2);
1696 if (user->state != USER_ACTIVE)
1698 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1707 if (user->state != USER_ACTIVE)
1715 drop->cause = user->cause[0];
1716 cc_user_send(user, ATMOP_DROP_PARTY, drop, sizeof(*drop));
1729 if (user->aborted) {
1730 cc_user_err(user, ATMERR_PREVIOUSLY_ABORTED);
1734 conn = cc_query_check(user);
1736 cc_user_err(user, ATMERR_BAD_STATE);
1742 cc_attr_query(user, conn, &req->attr, 1);
1753 conn = cc_query_check(user);
1755 cc_user_err(user, ATMERR_BAD_STATE);
1761 cc_attr_query(user, conn, req->attr, req->count);
1772 if (user->aborted) {
1773 cc_user_err(user, ATMERR_PREVIOUSLY_ABORTED);
1777 conn = cc_set_check(user);
1779 cc_user_err(user, ATMERR_BAD_STATE);
1784 cc_attr_set(user, conn, &req->attr, 1, (u_char *)(req + 1),
1796 conn = cc_set_check(user);
1798 cc_user_err(user, ATMERR_BAD_STATE);
1804 cc_attr_set(user, conn, req->attr, req->count,
1817 strcpy(state.name, user->name);
1818 switch (user->state) {
1821 if (user->accepted != NULL)
1841 switch (user->config) {
1876 cc_user_ok(user, ATMRESP_STATE, &state, sizeof(state));
1886 list = cc_get_local_port_info(user->cc,
1891 cc_user_err(user, ATMERR_NOMEM);
1894 cc_user_ok(user, ATMRESP_PORTS, list, list_len);
1905 cc_user_abort(user, &abo->cause);
1907 cc_user_ok(user, ATMRESP_NONE, NULL, 0);
1912 if (user->cc->log & CCLOG_USER_SIG)
1913 cc_user_log(user, "bad signal=%u in state=%u",
1914 sig, user->state);
1918 if (user->cc->log & CCLOG_USER_SIG)
1919 cc_user_log(user, "bad state=%u for signal=%u",
1920 user->state, sig);