Lines Matching refs:cm
58 static int close_conn_mt_when_nouser(ns_conn_mt_t *cm);
62 static void close_conn_mt_by_procchg(ns_conn_mt_t *cm, int rc, char *errmsg);
94 #define NS_CONN_UNLOCK_AND_FREE(free, cm, cmg) \
96 (void) mutex_unlock(&(cm)->lock); \
98 cmg = free_conn_mt((cm), 1); \
887 ns_conn_mt_t *cm;
890 cm = (ns_conn_mt_t *)calloc(1, sizeof (*cm));
891 if (cm == NULL) {
908 (void) mutex_init(&cm->lock, USYNC_THREAD, NULL);
909 cm->state = NS_CONN_MT_CONNECTING;
910 cm->tid = thr_self();
911 cm->pid = getpid();
912 cm->next = NULL;
913 cm->cu_head = NULL;
914 cm->cu_tail = NULL;
915 cm->conn = NULL;
916 cm->conn_mgmt = cmg;
918 return (cm);
927 free_conn_mt(ns_conn_mt_t *cm, int unlock_cmg)
931 if (cm == NULL)
933 if (cm->ns_error != NULL)
934 (void) __ns_ldap_freeError(&cm->ns_error);
935 if (cm->conn != NULL) {
936 if (cm->conn->ld != NULL)
937 (void) ldap_unbind(cm->conn->ld);
938 __s_api_freeConnection(cm->conn);
940 cmg = cm->conn_mgmt;
941 free(cm);
947 add_cu2cm(ns_conn_user_t *cu, ns_conn_mt_t *cm)
950 if (cm->cu_head == NULL) {
951 cm->cu_head = cu;
952 cm->cu_tail = cu;
954 cm->cu_tail->next = cu;
955 cm->cu_tail = cu;
957 cm->cu_cnt++;
962 add_cm2cmg(ns_conn_mt_t *cm, ns_conn_mgmt_t *cmg)
971 cmg->cm_head = cm;
972 cmg->cm_tail = cm;
974 if (cm->opened_for == NS_CONN_USER_WRITE) {
975 cm->next = cmg->cm_head;
976 cmg->cm_head = cm;
978 cmg->cm_tail->next = cm;
979 cmg->cm_tail = cm;
987 del_cu4cm(ns_conn_user_t *cu, ns_conn_mt_t *cm)
991 if (cu == NULL || cm->cu_head == NULL || cm->cu_cnt == 0)
995 if (cm->cu_head == cm->cu_tail) {
996 if (cu == cm->cu_head) {
997 cm->cu_head = cm->cu_tail = NULL;
998 cm->cu_cnt = 0;
1005 if (cu == cm->cu_head) {
1006 cm->cu_head = cu->next;
1007 cm->cu_cnt--;
1012 pu = cm->cu_head;
1013 for (u = cm->cu_head->next; u; u = u->next) {
1018 if (pu != cm->cu_tail) {
1021 cm->cu_tail = pu;
1022 cm->cu_cnt--;
1032 del_cm4cmg(ns_conn_mt_t *cm, ns_conn_mgmt_t *cmg)
1036 if (cm == NULL || cmg->cm_head == NULL || cmg->cm_cnt == 0)
1041 if (cm == cmg->cm_head) {
1044 cm->next = NULL;
1049 /* more than one and cm is the first one */
1050 if (cm == cmg->cm_head) {
1051 cmg->cm_head = cm->next;
1053 cm->next = NULL;
1059 if (cm == m)
1064 pm->next = cm->next;
1068 cm->next = NULL;
1081 ns_conn_mt_t *cm)
1083 Connection *cp = cm->conn;
1106 wait_for_conn_mt(ns_conn_user_t *cu, ns_conn_mt_t *cm)
1110 add_cu2cm(cu, cm);
1111 cu->conn_mt = cm;
1113 (void) mutex_unlock(&cm->lock);
1116 * cm->conn_mgmt across the wait
1118 (void) mutex_unlock(&(cm->conn_mgmt)->lock);
1120 (void) mutex_lock(&cm->lock);
1122 if (cm->state == NS_CONN_MT_CONNECTING) {
1123 (void) conn_wait(cm, cu);
1125 /* cm->lock is locked again at this point */
1130 if (cm->state == NS_CONN_MT_CONNECTED)
1133 del_cu4cm(cu, cm);
1141 * Check and see if the input MT connection '*cm' should be closed.
1146 * to be closed), otherwise unlock mutex (*cm)->lock and return B_TRUE.
1147 * This function assumes conn_mgmt cmg and conn_mt *cm are locked.
1150 check_and_close_conn(ns_conn_mgmt_t *cmg, ns_conn_mt_t **cm,
1193 if (strcasecmp(cmg->pservers[j], (*cm)->conn->serverAddr) != 0)
1228 if ((*cm)->opened_for == NS_CONN_USER_WRITE ||
1229 (*cm)->referral == B_TRUE) {
1233 free_cm = close_conn_mt_when_nouser(*cm);
1240 /* cu has not been attached to cm yet, use NULL as cu pointer */
1241 free_cm = close_conn_mt(*cm, LDAP_SERVER_DOWN, &ep, NULL);
1247 (void) mutex_unlock(&(*cm)->lock);
1249 (void) free_conn_mt(*cm, 0);
1250 *cm = NULL;
1263 * conn_mt *cmt and conn_mgmt cm->conn_mgmt are assumed locked.
1264 * cm->lock is unlocked at exit if rc is B_FALSE.
1274 ns_conn_mt_t *cm = *cmt;
1275 ns_conn_mgmt_t *cmg = cm->conn_mgmt;
1277 if (cm->state != st || cm->close_when_nouser == B_TRUE ||
1278 cm->detached == B_TRUE || cm->pid != getpid() ||
1279 cm->referral != cu->referral) {
1280 (void) mutex_unlock(&cm->lock);
1295 if (cm->opened_for == NS_CONN_USER_WRITE &&
1296 cu->type != NS_CONN_USER_WRITE && cm->cu_cnt == 0 &&
1297 ((time(NULL) - cm->access_time) > 60)) {
1302 free_cm = close_conn_mt(cm, NS_LDAP_INTERNAL, NULL, NULL);
1303 (void) mutex_unlock(&cm->lock);
1305 (void) free_conn_mt(cm, 0);
1314 if (cm->opened_for == NS_CONN_USER_SEARCH ||
1315 cm->opened_for == NS_CONN_USER_GETENT)
1320 if (cm->opened_for == NS_CONN_USER_WRITE)
1330 is_server_cred_matched(server, cred, cm) == B_FALSE))
1342 if (cm->state == NS_CONN_MT_CONNECTED &&
1344 drop_conn = check_and_close_conn(cmg, &cm, cu);
1346 if (cm == NULL)
1353 if ((cm->state == NS_CONN_MT_CONNECTED &&
1354 cm->cu_max != NS_CONN_MT_USER_NO_MAX &&
1355 cm->cu_cnt >= cm->cu_max) ||
1356 (cm->state == NS_CONN_MT_CONNECTING &&
1357 cm->cu_max != NS_CONN_MT_USER_NO_MAX &&
1358 cm->waiter_cnt >= cm->cu_max - 1))
1363 (void) mutex_unlock(&cm->lock);
1537 ns_conn_mt_t *cm = cu->conn_mt;
1551 (void) mutex_lock(&cm->lock);
1552 cm->conn = con;
1553 cm->state = NS_CONN_MT_CONNECTED;
1554 cm->pid = getpid();
1555 cm->create_time = time(NULL);
1556 cm->access_time = cm->create_time;
1557 cm->opened_for = cu->type;
1558 add_cu2cm(cu, cm);
1559 cu->conn_mt = cm;
1562 cm->cu_max = NS_CONN_MT_USER_MAX;
1564 cm->cu_max = 1;
1567 (void) conn_signal(cm);
1569 (void) mutex_unlock(&cm->lock);
1585 ns_conn_mt_t *cm;
1590 cm = cu->conn_mt;
1591 if (cm == NULL)
1595 (void) mutex_lock(&cm->lock);
1596 del_cu4cm(cu, cm);
1606 if ((cm->close_when_nouser == B_TRUE ||
1607 cm->state != NS_CONN_MT_CONNECTED) && cm->cu_cnt == 0) {
1608 (void) mutex_unlock(&cm->lock);
1610 (void) mutex_lock(&cm->lock);
1611 del_cm4cmg(cm, cmg);
1613 NS_CONN_UNLOCK_AND_FREE(ns_conn_free, cm, cmg);
1615 if (cm->state == NS_CONN_MT_CONNECTED && cm->cu_cnt == 0 &&
1616 cm->conn != NULL && cm->conn->ld != NULL) {
1622 while (ldap_result(cm->conn->ld, LDAP_RES_ANY,
1628 (void) mutex_unlock(&cm->lock);
1634 err2cm(ns_conn_mt_t *cm, int rc, ns_ldap_error_t **errorp) {
1637 cm->ns_rc = rc;
1638 cm->ns_error = NULL;
1642 cm->ns_rc = NS_LDAP_MEMORY;
1644 cm->ns_error = ep;
1650 err_from_cm(ns_conn_user_t *cu, ns_conn_mt_t *cm) {
1653 cu->ns_rc = cm->ns_rc;
1657 if (cm->ns_rc != NS_LDAP_SUCCESS && cm->ns_error != NULL) {
1658 ep = __s_api_copy_error(cm->ns_error);
1688 * errorp : set to NULL, if none NULL cm, callers do not need to free it
1694 ns_conn_mt_t *cm;
1699 if ((cm = cu->conn_mt) == NULL)
1704 (void) mutex_lock(&cm->lock);
1705 if (cm->state != NS_CONN_MT_CONNECT_ERROR) {
1706 cm->state = NS_CONN_MT_CONNECT_ERROR;
1707 cm->ns_rc = rc;
1709 cm->ns_error = *errorp;
1715 err_from_cm(cu, cm);
1717 (void) conn_signal(cm);
1719 del_cu4cm(cu, cm);
1722 if (cm->cu_cnt == 0) {
1723 del_cm4cmg(cm, cmg);
1727 NS_CONN_UNLOCK_AND_FREE(free_cm, cm, cmg);
1777 * Assume cm not null and locked, assume conn_mgmt is also locked.
1778 * Return -1 if error, 1 if the cm should be freed, otherwise 0.
1781 close_conn_mt(ns_conn_mt_t *cm, int rc, ns_ldap_error_t **errorp,
1784 ns_conn_mgmt_t *cmg = cm->conn_mgmt;
1788 if ((cm->state != NS_CONN_MT_CONNECTED && cm->state !=
1794 if (cm == m)
1800 if (cm->state == NS_CONN_MT_CONNECTED) { /* first time in here */
1801 cm->state = NS_CONN_MT_CLOSING;
1804 * it to the cm. If the caller calls on behalf of
1811 if ((cu != NULL && cm->cu_cnt > 1) ||
1812 (cu == NULL && cm->cu_cnt > 0)) {
1813 err2cm(cm, rc, errorp);
1815 (void) conn_signal(cm);
1819 if (cm->cu_head != NULL) {
1820 for (u = cm->cu_head; u; u = u->next) {
1829 if ((cu != NULL && cm->cu_cnt == 1) ||
1830 (cu == NULL && cm->cu_cnt == 0)) {
1831 del_cm4cmg(cm, cmg);
1832 cm->detached = B_TRUE;
1855 ns_conn_mt_t *cm;
1861 if (cu->state != NS_CONN_USER_CONNECTED || (cm = cu->conn_mt) == NULL)
1866 (void) mutex_lock(&cm->lock);
1869 free_cm = close_conn_mt(cm, rc, errorp, cu);
1871 (void) mutex_unlock(&cm->lock);
1879 err_from_cm(cu, cm);
1883 del_cu4cm(cu, cm);
1888 NS_CONN_UNLOCK_AND_FREE(free_cm, cm, cmg);
1898 close_conn_mt_by_procchg(ns_conn_mt_t *cm, int rc, char *errmsg)
1904 if (cm == NULL)
1906 cmg = cm->conn_mgmt;
1916 (void) mutex_lock(&cm->lock);
1919 free_cm = close_conn_mt(cm, LDAP_SERVER_DOWN, &ep, NULL);
1921 (void) mutex_unlock(&cm->lock);
1927 NS_CONN_UNLOCK_AND_FREE(free_cm, cm, cmg);
1938 close_conn_mt_when_nouser(ns_conn_mt_t *cm)
1942 if (cm->cu_cnt == 0) {
1943 del_cm4cmg(cm, cm->conn_mgmt);
1946 cm->close_when_nouser = B_TRUE;
1996 ns_conn_mt_t *cm;
2030 for (cm = cmg->cm_head; cm; cm = cm->next) {
2031 (void) mutex_lock(&cm->lock);
2033 if (cm->state == NS_CONN_MT_CONNECTED &&
2034 cm->conn != NULL &&
2035 strcasecmp(cm->conn->serverAddr, s) == 0) {
2036 (void) mutex_unlock(&cm->lock);
2040 (void) mutex_unlock(&cm->lock);
2042 if (cm != NULL) {
2045 close_conn_mt_by_procchg(cm, LDAP_SERVER_DOWN,
2048 * Process the next cm using server s.
2049 * Start from the head of the cm linked
2050 * list again, as the cm list may change
2117 for (cm = cmg->cm_head; cm; cm = cm->next) {
2118 (void) mutex_lock(&cm->lock);
2125 if (cm->state == NS_CONN_MT_CONNECTED &&
2126 cm->close_when_nouser == B_FALSE &&
2127 cm->conn != NULL && cm->opened_for !=
2129 cm->referral == B_FALSE) {
2135 * again, but cm is bound prior to
2141 cm->conn->serverAddr,
2151 * used by the cm (i.e., no match
2157 cm);
2159 cm, cmg);
2164 * check the entire cm
2167 * cm list.
2172 (void) mutex_unlock(&cm->lock);
2174 /* if no (more) cm using s, check next server */
2175 if (cm == NULL)
2189 ns_conn_mt_t *cm;
2201 for (cm = cmg->cm_head; cm; cm = cm->next) {
2202 (void) mutex_lock(&cm->lock);
2203 if (cm->next == NULL)
2206 free_cm = close_conn_mt(cm, LDAP_OTHER, &ep, NULL);
2207 (void) mutex_unlock(&cm->lock);
2209 (void) free_conn_mt(cm, 0);