/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2010 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * NetBIOS name resolution node types. * * A B-node (broadcast node) uses broadcasts for name registration * and resolution. Routers typically do not forward broadcasts and * only computers on the local subnet will respond. * * A P-node (peer-to-peer node) uses a NetBIOS name server (WINS) * to resolve NetBIOS names, which allows it to work across routers. * In order to function in a P-node environment, all computers must * be configured to use the NetBIOS name server because P-nodes do * not broadcast on the network. * * A mixed node (M-node) behaves as a B-node by default. If it cannot * resolve the name via broadcast then it tries a NetBIOS name server * lookup (P-node). * * A hybrid node (H-node) behaves as a P-node by default. If it cannot * resolve the name using a NetBIOS name server then it resorts to * broadcasts (B-node). * * NetBIOS Name Service Protocols * * A REQUEST packet is always sent to the well known UDP port 137. * The destination address is normally either the IP broadcast address or * the address of the NAME - the address of the NAME server it set up at * initialization time. In rare cases, a request packet will be sent to * an end node, e.g. a NAME QUERY REQUEST sent to "challenge" a node. * * A RESPONSE packet is always sent to the source UDP port and source IP * address of the request packet. * * A DEMAND packet must always be sent to the well known UDP port 137. * There is no restriction on the target IP address. * * A transaction ID is a value composed from the requestor's IP address and * a unique 16 bit value generated by the originator of the transaction. */ #include <unistd.h> #include <syslog.h> #include <stdlib.h> #include <synch.h> #include <errno.h> #include <netdb.h> #include <sys/socket.h> #include <sys/sockio.h> #include <arpa/inet.h> #include <net/if_arp.h> #include <smbsrv/libsmbns.h> #include <smbns_netbios.h> /* * RFC 1002 4.2.1.1. HEADER */ #define QUESTION_TYPE_NETBIOS_GENERAL 0x20 #define QUESTION_TYPE_NETBIOS_STATUS 0x21 #define QUESTION_CLASS_INTERNET 0x0001 /* * RFC 1002 4.2.1.3. RESOURCE RECORD */ #define RR_TYPE_IP_ADDRESS_RESOURCE 0x0001 #define RR_TYPE_NAME_SERVER_RESOURCE 0x0002 #define RR_TYPE_NULL_RESOURCE 0x000A #define RR_TYPE_NETBIOS_RESOURCE 0x0020 #define RR_TYPE_NETBIOS_STATUS 0x0021 /* * * RESOURCE RECORD RR_CLASS field definitions */ #define RR_CLASS_INTERNET_CLASS 0x0001 /* * NB_FLAGS field of the RESOURCE RECORD RDATA field for RR_TYPE of NB. */ #define RR_FLAGS_NB_ONT_MASK 0x6000 #define RR_FLAGS_NB_ONT_B_NODE 0x0000 #define RR_FLAGS_NB_ONT_P_NODE 0x2000 #define RR_FLAGS_NB_ONT_M_NODE 0x4000 #define RR_FLAGS_NB_ONT_RESERVED 0x6000 #define RR_FLAGS_NB_GROUP_NAME 0x8000 #define NAME_FLAGS_PERMANENT_NAME 0x0200 #define NAME_FLAGS_ACTIVE_NAME 0x0400 #define NAME_FLAGS_CONFLICT 0x0800 #define NAME_FLAGS_DEREGISTER 0x1000 #define NAME_FLAGS_ONT_MASK 0x6000 #define NAME_FLAGS_ONT_B_NODE 0x0000 #define NAME_FLAGS_ONT_P_NODE 0x2000 #define NAME_FLAGS_ONT_M_NODE 0x4000 #define NAME_FLAGS_ONT_RESERVED 0x6000 #define NAME_FLAGS_GROUP_NAME 0x8000 #define MAX_NETBIOS_REPLY_DATA_SIZE 500 #define NAME_HEADER_SIZE 12 typedef struct nbt_name_reply { struct nbt_name_reply *forw; struct nbt_name_reply *back; struct name_packet *packet; addr_entry_t *addr; uint16_t name_trn_id; boolean_t reply_ready; } nbt_name_reply_t; static nbt_name_reply_t reply_queue; static mutex_t rq_mtx; static cond_t rq_cv; static mutex_t nbt_name_config_mtx; static name_queue_t delete_queue; static name_queue_t refresh_queue; static int name_sock = 0; static int bcast_num = 0; static int nbns_num = 0; static addr_entry_t smb_bcast_list[SMB_PI_MAX_NETWORKS]; static addr_entry_t smb_nbns[SMB_PI_MAX_WINS]; static int smb_netbios_process_response(uint16_t, addr_entry_t *, struct name_packet *, uint32_t); static int smb_send_name_service_packet(addr_entry_t *addr, struct name_packet *packet); /* * Allocate a transaction id. */ static uint16_t smb_netbios_name_trn_id(void) { static uint16_t trn_id; static mutex_t trn_id_mtx; (void) mutex_lock(&trn_id_mtx); do { ++trn_id; } while (trn_id == 0 || trn_id == (uint16_t)-1); (void) mutex_unlock(&trn_id_mtx); return (trn_id); } static int smb_end_node_challenge(nbt_name_reply_t *reply_info) { int rc; uint32_t retry; uint16_t tid; struct resource_record *answer; struct name_question question; addr_entry_t *addr; struct name_entry *destination; struct name_packet packet; struct timespec st; /* * The response packet has in it the address of the presumed owner * of the name. Challenge that owner. If owner either does not * respond or indicates that he no longer owns the name, claim the * name. Otherwise, the name cannot be claimed. */ if ((answer = reply_info->packet->answer) == 0) return (-1); destination = answer->name; question.name = answer->name; packet.info = NAME_QUERY_REQUEST | NM_FLAGS_UNICAST; packet.qdcount = 1; /* question entries */ packet.question = &question; packet.ancount = 0; /* answer recs */ packet.answer = NULL; packet.nscount = 0; /* authority recs */ packet.authority = NULL; packet.arcount = 0; /* additional recs */ packet.additional = NULL; addr = &destination->addr_list; for (retry = 0; retry < UCAST_REQ_RETRY_COUNT; retry++) { tid = smb_netbios_name_trn_id(); packet.name_trn_id = tid; if (smb_send_name_service_packet(addr, &packet) >= 0) { if ((rc = smb_netbios_process_response(tid, addr, &packet, UCAST_REQ_RETRY_TIMEOUT)) != 0) return (rc); } st.tv_sec = 0; st.tv_nsec = (UCAST_REQ_RETRY_TIMEOUT * 1000000); (void) nanosleep(&st, 0); } /* No reply */ return (0); } static nbt_name_reply_t * smb_name_get_reply(uint16_t tid, uint32_t timeout) { uint16_t info; struct resource_record *answer; nbt_name_reply_t *reply; uint32_t wait_time, to_save; /* in millisecond */ struct timeval wt; timestruc_t to; to_save = timeout; reply = malloc(sizeof (nbt_name_reply_t)); if (reply != NULL) { reply->reply_ready = B_FALSE; reply->name_trn_id = tid; (void) mutex_lock(&rq_mtx); QUEUE_INSERT_TAIL(&reply_queue, reply); (void) mutex_unlock(&rq_mtx); for (;;) { (void) gettimeofday(&wt, 0); wait_time = wt.tv_usec / 1000; to.tv_sec = 0; to.tv_nsec = timeout * 1000000; (void) mutex_lock(&rq_mtx); (void) cond_reltimedwait(&rq_cv, &rq_mtx, &to); (void) mutex_unlock(&rq_mtx); if (reply->reply_ready) { info = reply->packet->info; if (PACKET_TYPE(info) == WACK_RESPONSE) { answer = reply->packet->answer; wait_time = (answer) ? TO_MILLISECONDS(answer->ttl) : DEFAULT_TTL; free(reply->addr); free(reply->packet); timeout = to_save + wait_time; reply->reply_ready = B_FALSE; reply->name_trn_id = tid; (void) mutex_lock(&rq_mtx); QUEUE_INSERT_TAIL(&reply_queue, reply); (void) mutex_unlock(&rq_mtx); continue; } return (reply); } (void) gettimeofday(&wt, 0); wait_time = (wt.tv_usec / 1000) - wait_time; if (wait_time >= timeout) { (void) mutex_lock(&rq_mtx); QUEUE_CLIP(reply); (void) mutex_unlock(&rq_mtx); free(reply); break; } timeout -= wait_time; } } return (0); } static void smb_reply_ready(struct name_packet *packet, addr_entry_t *addr) { nbt_name_reply_t *reply; struct resource_record *answer; (void) mutex_lock(&rq_mtx); for (reply = reply_queue.forw; reply != &reply_queue; reply = reply->forw) { if (reply->name_trn_id == packet->name_trn_id) { QUEUE_CLIP(reply); reply->addr = addr; reply->packet = packet; reply->reply_ready = B_TRUE; (void) cond_signal(&rq_cv); (void) mutex_unlock(&rq_mtx); return; } } (void) mutex_unlock(&rq_mtx); /* Presumably nobody is waiting any more... */ free(addr); answer = packet->answer; if (answer) smb_netbios_name_freeaddrs(answer->name); free(packet); } static int smb_netbios_process_response(uint16_t tid, addr_entry_t *addr, struct name_packet *packet, uint32_t timeout) { int rc = 0; uint16_t info; nbt_name_reply_t *reply; struct resource_record *answer; struct name_entry *name; struct name_entry *entry; struct name_question *question; uint32_t ttl; if ((reply = smb_name_get_reply(tid, timeout)) == 0) { return (0); /* No reply: retry */ } info = reply->packet->info; answer = reply->packet->answer; /* response */ switch (PACKET_TYPE(info)) { case NAME_QUERY_RESPONSE: if (POSITIVE_RESPONSE(info)) { addr = &answer->name->addr_list; do { /* * Make sure that remote name is not * flagged local */ addr->attributes &= ~NAME_ATTR_LOCAL; if (answer->ttl) addr->ttl = answer->ttl; else addr->ttl = DEFAULT_TTL; addr->refresh_ttl = TO_SECONDS(addr->ttl); addr->ttl = addr->refresh_ttl; addr = addr->forw; } while (addr != &answer->name->addr_list); smb_netbios_name_logf(answer->name); (void) smb_netbios_cache_insert_list(answer->name); rc = 1; } else { rc = -1; } break; case NAME_REGISTRATION_RESPONSE: if (NEGATIVE_RESPONSE(info)) { if (RCODE(info) == RCODE_CFT_ERR) { if (answer == 0) { rc = -RCODE(info); break; } name = answer->name; entry = smb_netbios_cache_lookup(name); if (entry) { /* * a name in the state "conflict * detected" does not "logically" exist * on that node. No further session * will be accepted on that name. * No datagrams can be sent against * that name. * Such an entry will not be used for * purposes of processing incoming * request packets. * The only valid user NetBIOS operation * against such a name is DELETE NAME. */ entry->attributes |= NAME_ATTR_CONFLICT; syslog(LOG_DEBUG, "nbns: name conflict: %15.15s", entry->name); smb_netbios_cache_unlock_entry(entry); } } rc = -RCODE(info); break; } /* * name can be added: * adjust refresh timeout value, * TTL, for this name */ question = packet->question; ttl = (answer && answer->ttl) ? answer->ttl : DEFAULT_TTL; ttl = TO_SECONDS(ttl); if ((entry = smb_netbios_cache_lookup(question->name)) != 0) { addr = &entry->addr_list; do { if ((addr->refresh_ttl == 0) || (ttl < addr->refresh_ttl)) addr->refresh_ttl = addr->ttl = ttl; addr = addr->forw; } while (addr != &entry->addr_list); smb_netbios_cache_unlock_entry(entry); } rc = 1; break; case NAME_RELEASE_RESPONSE: rc = 1; break; case END_NODE_CHALLENGE_REGISTRATION_REQUEST: /* * The response packet has in it the * address of the presumed owner of the * name. Challenge that owner. If * owner either does not respond or * indicates that he no longer owns the * name, claim the name. Otherwise, * the name cannot be claimed. */ rc = smb_end_node_challenge(reply); break; default: rc = 0; break; } if (answer) smb_netbios_name_freeaddrs(answer->name); free(reply->addr); free(reply->packet); free(reply); return (rc); /* retry */ } /* * smb_name_buf_from_packet * * Description: * Convert a NetBIOS Name Server Packet Block (npb) * into the bits and bytes destined for the wire. * The "buf" is used as a heap. * * Inputs: * char * buf -> Buffer, from the wire * unsigned n_buf -> Length of 'buf' * name_packet *npb -> Packet block, decode into * unsigned n_npb -> Max bytes in 'npb' * * Returns: * >0 -> Encode successful, value is length of packet in "buf" * -1 -> Hard error, can not possibly encode * -2 -> Need more memory in buf -- it's too small */ static int smb_name_buf_from_packet(unsigned char *buf, int n_buf, struct name_packet *npb) { addr_entry_t *raddr; unsigned char *heap = buf; unsigned char *end_heap = heap + n_buf; unsigned char *dnptrs[32]; unsigned char comp_name_buf[MAX_NAME_LENGTH]; unsigned int tmp; int i, step; if (n_buf < NAME_HEADER_SIZE) return (-1); /* no header, impossible */ dnptrs[0] = heap; dnptrs[1] = 0; BE_OUT16(heap, npb->name_trn_id); heap += 2; BE_OUT16(heap, npb->info); heap += 2; BE_OUT16(heap, npb->qdcount); heap += 2; BE_OUT16(heap, npb->ancount); heap += 2; BE_OUT16(heap, npb->nscount); heap += 2; BE_OUT16(heap, npb->arcount); heap += 2; for (i = 0; i < npb->qdcount; i++) { if ((heap + 34 + 4) > end_heap) return (-2); (void) smb_first_level_name_encode(npb->question[i].name, comp_name_buf, sizeof (comp_name_buf)); (void) strcpy((char *)heap, (char *)comp_name_buf); heap += strlen((char *)comp_name_buf) + 1; BE_OUT16(heap, npb->question[i].question_type); heap += 2; BE_OUT16(heap, npb->question[i].question_class); heap += 2; } for (step = 1; step <= 3; step++) { struct resource_record *nrr; int n; /* truly ugly, but saves code copying */ if (step == 1) { n = npb->ancount; nrr = npb->answer; } else if (step == 2) { n = npb->nscount; nrr = npb->authority; } else { /* step == 3 */ n = npb->arcount; nrr = npb->additional; } for (i = 0; i < n; i++) { if ((heap + 34 + 10) > end_heap) return (-2); (void) smb_first_level_name_encode(nrr->name, comp_name_buf, sizeof (comp_name_buf)); (void) strcpy((char *)heap, (char *)comp_name_buf); heap += strlen((char *)comp_name_buf) + 1; BE_OUT16(heap, nrr[i].rr_type); heap += 2; BE_OUT16(heap, nrr[i].rr_class); heap += 2; BE_OUT32(heap, nrr[i].ttl); heap += 4; BE_OUT16(heap, nrr[i].rdlength); heap += 2; if ((tmp = nrr[i].rdlength) > 0) { if ((heap + tmp) > end_heap) return (-2); if (nrr[i].rr_type == NAME_RR_TYPE_NB && nrr[i].rr_class == NAME_RR_CLASS_IN && tmp >= 6 && nrr[i].rdata == 0) { tmp = nrr[i].name->attributes & (NAME_ATTR_GROUP | NAME_ATTR_OWNER_NODE_TYPE); BE_OUT16(heap, tmp); heap += 2; raddr = &nrr[i].name->addr_list; (void) memcpy(heap, &raddr->sin.sin_addr.s_addr, sizeof (uint32_t)); heap += 4; } else { bcopy(nrr[i].rdata, heap, tmp); heap += tmp; } } } } return (heap - buf); } /* * strnchr * * Lookup for character 'c' in first 'n' chars of string 's'. * Returns pointer to the found char, otherwise returns 0. */ static char * strnchr(const char *s, char c, int n) { char *ps = (char *)s; char *es = (char *)s + n; while (ps < es && *ps) { if (*ps == c) return (ps); ++ps; } if (*ps == '\0' && c == '\0') return (ps); return (0); } static boolean_t is_multihome(char *name) { return (smb_nic_getnum(name) > 1); } /* * smb_netbios_getname * * Get the Netbios name part of the given record. * Does some boundary checks. * * Returns the name length on success, otherwise * returns 0. */ static int smb_netbios_getname(char *name, char *buf, char *buf_end) { char *name_end; int name_len; if (buf >= buf_end) { /* no room for a NB name */ return (0); } name_end = strnchr(buf, '\0', buf_end - buf + 1); if (name_end == 0) { /* not a valid NB name */ return (0); } name_len = name_end - buf + 1; (void) strlcpy(name, buf, name_len); return (name_len); } /* * smb_name_buf_to_packet * * Convert the bits and bytes that came from the wire into a NetBIOS * Name Server Packet Block (npb). The "block" is used as a heap. * * Returns a pointer to a name packet on success. Otherwise, returns * a NULL pointer. */ static struct name_packet * smb_name_buf_to_packet(char *buf, int n_buf) { struct name_packet *npb; unsigned char *heap; unsigned char *scan = (unsigned char *)buf; unsigned char *scan_end = scan + n_buf; char name_buf[MAX_NAME_LENGTH]; struct resource_record *nrr = 0; int rc, i, n, nn, ns; uint16_t name_trn_id, info; uint16_t qdcount, ancount, nscount, arcount; addr_entry_t *next; int name_len; if (n_buf < NAME_HEADER_SIZE) { /* truncated header */ syslog(LOG_DEBUG, "nbns: short packet (%d bytes)", n_buf); return (NULL); } name_trn_id = BE_IN16(scan); scan += 2; info = BE_IN16(scan); scan += 2; qdcount = BE_IN16(scan); scan += 2; ancount = BE_IN16(scan); scan += 2; nscount = BE_IN16(scan); scan += 2; arcount = BE_IN16(scan); scan += 2; ns = sizeof (struct name_entry); n = n_buf + sizeof (struct name_packet) + ((unsigned)qdcount * (sizeof (struct name_question) + ns)) + ((unsigned)ancount * (sizeof (struct resource_record) + ns)) + ((unsigned)nscount * (sizeof (struct resource_record) + ns)) + ((unsigned)arcount * (sizeof (struct resource_record) + ns)); if ((npb = malloc(n)) == NULL) return (NULL); bzero(npb, n); heap = npb->block_data; npb->name_trn_id = name_trn_id; npb->info = info; npb->qdcount = qdcount; npb->ancount = ancount; npb->nscount = nscount; npb->arcount = arcount; /* scan is in position for question entries */ /* * Measure the space needed for the tables */ if (qdcount > 0) { /* LINTED - E_BAD_PTR_CAST_ALIGN */ npb->question = (struct name_question *)heap; heap += qdcount * sizeof (struct name_question); for (i = 0; i < qdcount; i++) { /* LINTED - E_BAD_PTR_CAST_ALIGN */ npb->question[i].name = (struct name_entry *)heap; heap += sizeof (struct name_entry); } } /* LINTED - E_BAD_PTR_CAST_ALIGN */ nrr = (struct resource_record *)heap; if (ancount > 0) { /* LINTED - E_BAD_PTR_CAST_ALIGN */ npb->answer = (struct resource_record *)heap; heap += ancount * sizeof (struct resource_record); } if (nscount > 0) { /* LINTED - E_BAD_PTR_CAST_ALIGN */ npb->authority = (struct resource_record *)heap; heap += nscount * sizeof (struct resource_record); } if (arcount > 0) { /* LINTED - E_BAD_PTR_CAST_ALIGN */ npb->additional = (struct resource_record *)heap; heap += arcount * sizeof (struct resource_record); } /* * Populate each resource_record's .name field. * Done as a second pass so that all resource records * (answer, authority, additional) are consecutive via nrr[i]. */ for (i = 0; i < (ancount + nscount + arcount); i++) { /* LINTED - E_BAD_PTR_CAST_ALIGN */ nrr[i].name = (struct name_entry *)heap; heap += sizeof (struct name_entry); } for (i = 0; i < npb->qdcount; i++) { name_len = smb_netbios_getname(name_buf, (char *)scan, (char *)scan_end); if (name_len <= 0) { free(npb); return (NULL); } smb_init_name_struct(NETBIOS_EMPTY_NAME, 0, 0, 0, 0, 0, 0, npb->question[i].name); rc = smb_first_level_name_decode((unsigned char *)name_buf, npb->question[i].name); if (rc < 0) { /* Couldn't decode the question name */ free(npb); return (NULL); } scan += name_len; if (scan + 4 > scan_end) { /* no room for Question Type(2) and Class(2) fields */ free(npb); return (NULL); } npb->question[i].question_type = BE_IN16(scan); scan += 2; npb->question[i].question_class = BE_IN16(scan); scan += 2; } /* * Cheat. Remaining sections are of the same resource_record * format. Table space is consecutive. */ for (i = 0; i < (ancount + nscount + arcount); i++) { if (scan[0] == 0xc0) { /* Namebuf is reused... */ rc = 2; } else { name_len = smb_netbios_getname(name_buf, (char *)scan, (char *)scan_end); if (name_len <= 0) { free(npb); return (NULL); } rc = name_len; } scan += rc; if (scan + 10 > scan_end) { /* * no room for RR_TYPE (2), RR_CLASS (2), TTL (4) and * RDLENGTH (2) fields. */ free(npb); return (NULL); } smb_init_name_struct(NETBIOS_EMPTY_NAME, 0, 0, 0, 0, 0, 0, nrr[i].name); if ((rc = smb_first_level_name_decode((unsigned char *)name_buf, nrr[i].name)) < 0) { free(npb); return (NULL); } nrr[i].rr_type = BE_IN16(scan); scan += 2; nrr[i].rr_class = BE_IN16(scan); scan += 2; nrr[i].ttl = BE_IN32(scan); scan += 4; nrr[i].rdlength = BE_IN16(scan); scan += 2; if ((n = nrr[i].rdlength) > 0) { if ((scan + n) > scan_end) { /* no room for RDATA */ free(npb); return (NULL); } bcopy(scan, heap, n); nn = n; if (nrr[i].rr_type == 0x0020 && nrr[i].rr_class == 0x01 && n >= 6) { while (nn) { if (nn == 6) next = &nrr[i].name->addr_list; else { next = malloc( sizeof (addr_entry_t)); if (next == 0) { /* not enough memory */ free(npb); return (NULL); } QUEUE_INSERT_TAIL( &nrr[i].name->addr_list, next); } nrr[i].name->attributes = BE_IN16(scan); next->sin.sin_family = AF_INET; next->sinlen = sizeof (next->sin); (void) memcpy( &next->sin.sin_addr.s_addr, scan + 2, sizeof (uint32_t)); next->sin.sin_port = htons(IPPORT_NETBIOS_DGM); nn -= 6; scan += 6; } } else { nrr[i].rdata = heap; scan += n; } heap += n; } } return (npb); } /* * smb_send_name_service_packet * * Description: * * Send out a name service packet to proper destination. * * Inputs: * struct netbios_name *dest -> NETBIOS name of destination * struct name_packet *packet -> Packet to send * * Returns: * success -> >0 * failure -> <=0 */ static int smb_send_name_service_packet(addr_entry_t *addr, struct name_packet *packet) { unsigned char buf[MAX_DATAGRAM_LENGTH]; int len; if ((len = smb_name_buf_from_packet(buf, sizeof (buf), packet)) < 0) { errno = EINVAL; return (-1); } return (sendto(name_sock, buf, len, MSG_EOR, (struct sockaddr *)&addr->sin, addr->sinlen)); } /* * smb_netbios_send_rcv * * This function sends the given NetBIOS packet to the given * address and get back the response. If send operation is not * successful, it's repeated 'retries' times. * * Returns: * 0 Unsuccessful send operation; no reply * 1 Got reply */ static int smb_netbios_send_rcv(int bcast, addr_entry_t *destination, struct name_packet *packet, uint32_t retries, uint32_t timeout) { uint32_t retry; uint16_t tid; struct timespec st; int rc; for (retry = 0; retry < retries; retry++) { if ((destination->flags & ADDR_FLAG_VALID) == 0) return (0); tid = smb_netbios_name_trn_id(); packet->name_trn_id = tid; if (smb_send_name_service_packet(destination, packet) >= 0) { rc = smb_netbios_process_response(tid, destination, packet, timeout); if ((rc > 0) || (bcast == BROADCAST)) return (1); if (rc != 0) return (0); } st.tv_sec = 0; st.tv_nsec = (timeout * 1000000); (void) nanosleep(&st, 0); } return (0); } /* * RFC 1002 4.2.2. NAME REGISTRATION REQUEST */ static int smb_send_name_registration_request(int bcast, struct name_question *question, struct resource_record *additional) { int gotreply = 0; uint32_t retries; uint32_t timeout; addr_entry_t *destination; struct name_packet packet; unsigned char type; int i, addr_num, rc; type = question->name->name[15]; if ((type != NBT_WKSTA) && (type != NBT_SERVER)) { syslog(LOG_DEBUG, "nbns: name registration bad type (0x%02x)", type); smb_netbios_name_logf(question->name); question->name->attributes &= ~NAME_ATTR_LOCAL; return (-1); } if (bcast == BROADCAST) { if (bcast_num == 0) return (0); destination = smb_bcast_list; addr_num = bcast_num; retries = BCAST_REQ_RETRY_COUNT; timeout = BCAST_REQ_RETRY_TIMEOUT; packet.info = NAME_REGISTRATION_REQUEST | NM_FLAGS_BROADCAST; } else { if (nbns_num == 0) return (0); destination = smb_nbns; addr_num = nbns_num; retries = UCAST_REQ_RETRY_COUNT; timeout = UCAST_REQ_RETRY_TIMEOUT; packet.info = NAME_REGISTRATION_REQUEST | NM_FLAGS_UNICAST; } packet.qdcount = 1; /* question entries */ packet.question = question; packet.ancount = 0; /* answer recs */ packet.answer = NULL; packet.nscount = 0; /* authority recs */ packet.authority = NULL; packet.arcount = 1; /* additional recs */ packet.additional = additional; if (IS_UNIQUE(question->name->attributes) && (is_multihome((char *)(question->name->name)))) packet.info |= NAME_MULTIHOME_REGISTRATION_REQUEST; for (i = 0; i < addr_num; i++) { /* * Only register with the Primary WINS server, * unless we got no reply. */ if ((bcast == UNICAST) && gotreply) break; rc = smb_netbios_send_rcv(bcast, &destination[i], &packet, retries, timeout); if (rc == 1) gotreply = 1; } return (gotreply); } /* * RFC 1002 4.2.4. NAME REFRESH REQUEST */ /*ARGSUSED*/ static int smb_send_name_refresh_request(int bcast, struct name_question *question, struct resource_record *additional, int force) { int rc = 0; int gotreply = 0; uint32_t retries; uint32_t timeout; addr_entry_t *addr; addr_entry_t *destination; struct name_packet packet; unsigned char type; int i, addr_num, q_addrs = 0; type = question->name->name[15]; if ((type != NBT_WKSTA) && (type != NBT_SERVER)) { syslog(LOG_DEBUG, "nbns: name refresh bad type (0x%02x)", type); smb_netbios_name_logf(question->name); question->name->attributes &= ~NAME_ATTR_LOCAL; return (-1); } switch (bcast) { case BROADCAST : if (bcast_num == 0) return (-1); destination = smb_bcast_list; addr_num = bcast_num; retries = BCAST_REQ_RETRY_COUNT; timeout = BCAST_REQ_RETRY_TIMEOUT; packet.info = NAME_REFRESH_REQUEST | NM_FLAGS_BROADCAST; break; case UNICAST : if (nbns_num == 0) return (-1); destination = smb_nbns; addr_num = nbns_num; retries = UCAST_REQ_RETRY_COUNT; timeout = UCAST_REQ_RETRY_TIMEOUT; packet.info = NAME_REFRESH_REQUEST | NM_FLAGS_UNICAST; break; default: destination = &question->name->addr_list; /* * the value of addr_num is irrelvant here, because * the code is going to do special_process so it doesn't * need the addr_num. We set a value here just to avoid * compiler warning. */ addr_num = 0; retries = UCAST_REQ_RETRY_COUNT; timeout = UCAST_REQ_RETRY_TIMEOUT; packet.info = NAME_REFRESH_REQUEST | NM_FLAGS_UNICAST; q_addrs = 1; break; } if (IS_UNIQUE(question->name->attributes) && (is_multihome((char *)(question->name->name)))) packet.info |= NAME_MULTIHOME_REGISTRATION_REQUEST; packet.qdcount = 1; /* question entries */ packet.question = question; packet.ancount = 0; /* answer recs */ packet.answer = NULL; packet.nscount = 0; /* authority recs */ packet.authority = NULL; packet.arcount = 1; /* additional recs */ packet.additional = additional; if (q_addrs) goto special_process; for (i = 0; i < addr_num; i++) { rc = smb_netbios_send_rcv(bcast, &destination[i], &packet, retries, timeout); if (rc == 1) gotreply = 1; } return (gotreply); special_process: addr = destination; do { rc = smb_netbios_send_rcv(bcast, addr, &packet, retries, timeout); if (rc == 1) gotreply = 1; addr = addr->forw; } while (addr != destination); return (gotreply); } /* * RFC 1002 4.2.5. POSITIVE NAME REGISTRATION RESPONSE * RFC 1002 4.2.6. NEGATIVE NAME REGISTRATION RESPONSE */ static int smb_send_name_registration_response(addr_entry_t *addr, struct name_packet *original_packet, uint16_t rcode) { struct name_packet packet; struct resource_record answer; bzero(&packet, sizeof (struct name_packet)); bzero(&answer, sizeof (struct resource_record)); packet.name_trn_id = original_packet->name_trn_id; packet.info = NAME_REGISTRATION_RESPONSE | NAME_NM_FLAGS_RA | (rcode & NAME_RCODE_MASK); packet.qdcount = 0; /* question entries */ packet.question = NULL; packet.ancount = 1; /* answer recs */ packet.answer = &answer; packet.nscount = 0; /* authority recs */ packet.authority = NULL; packet.arcount = 0; /* additional recs */ packet.additional = NULL; answer.name = original_packet->question->name; answer.rr_type = NAME_QUESTION_TYPE_NB; answer.rr_class = NAME_QUESTION_CLASS_IN; answer.ttl = original_packet->additional->ttl; answer.rdlength = original_packet->additional->rdlength; answer.rdata = original_packet->additional->rdata; return (smb_send_name_service_packet(addr, &packet)); } /* * RFC 1002 4.2.9. NAME RELEASE REQUEST & DEMAND */ static int smb_send_name_release_request_and_demand(int bcast, struct name_question *question, struct resource_record *additional) { int gotreply = 0; int i, rc; int addr_num; uint32_t retries; uint32_t timeout; addr_entry_t *destination; struct name_packet packet; if (bcast == BROADCAST) { if (bcast_num == 0) return (-1); destination = smb_bcast_list; addr_num = bcast_num; retries = 1; /* BCAST_REQ_RETRY_COUNT */ timeout = 100; /* BCAST_REQ_RETRY_TIMEOUT */ packet.info = NAME_RELEASE_REQUEST | NM_FLAGS_BROADCAST; } else { if (nbns_num == 0) return (-1); destination = smb_nbns; addr_num = nbns_num; retries = 1; /* UCAST_REQ_RETRY_COUNT */ timeout = 100; /* UCAST_REQ_RETRY_TIMEOUT */ packet.info = NAME_RELEASE_REQUEST | NM_FLAGS_UNICAST; } packet.qdcount = 1; /* question entries */ packet.question = question; packet.ancount = 0; /* answer recs */ packet.answer = NULL; packet.nscount = 0; /* authority recs */ packet.authority = NULL; packet.arcount = 1; /* additional recs */ packet.additional = additional; for (i = 0; i < addr_num; i++) { rc = smb_netbios_send_rcv(bcast, &destination[i], &packet, retries, timeout); if (rc == 1) gotreply = 1; } return (gotreply); } /* * RFC 1002 4.2.10. POSITIVE NAME RELEASE RESPONSE * RFC 1002 4.2.11. NEGATIVE NAME RELEASE RESPONSE */ static int /* LINTED - E_STATIC_UNUSED */ smb_send_name_release_response(addr_entry_t *addr, struct name_packet *original_packet, uint16_t rcode) { struct name_packet packet; struct resource_record answer; bzero(&packet, sizeof (struct name_packet)); bzero(&answer, sizeof (struct resource_record)); packet.name_trn_id = original_packet->name_trn_id; packet.info = NAME_RELEASE_RESPONSE | (rcode & NAME_RCODE_MASK); packet.qdcount = 0; /* question entries */ packet.question = NULL; packet.ancount = 1; /* answer recs */ packet.answer = &answer; packet.nscount = 0; /* authority recs */ packet.authority = NULL; packet.arcount = 0; /* additional recs */ packet.additional = NULL; answer.name = original_packet->question->name; answer.rr_type = NAME_QUESTION_TYPE_NB; answer.rr_class = NAME_QUESTION_CLASS_IN; answer.ttl = original_packet->additional->ttl; answer.rdlength = original_packet->additional->rdlength; answer.rdata = original_packet->additional->rdata; return (smb_send_name_service_packet(addr, &packet)); } /* * RFC 1002 4.2.12. NAME QUERY REQUEST */ static int smb_send_name_query_request(int bcast, struct name_question *question) { int rc = 0; uint32_t retry, retries; uint32_t timeout; uint16_t tid; addr_entry_t *destination; struct name_packet packet; int i, addr_num; struct timespec st; if (bcast == BROADCAST) { if (bcast_num == 0) return (-1); destination = smb_bcast_list; addr_num = bcast_num; retries = BCAST_REQ_RETRY_COUNT; timeout = BCAST_REQ_RETRY_TIMEOUT; packet.info = NAME_QUERY_REQUEST | NM_FLAGS_BROADCAST; } else { if (nbns_num == 0) return (-1); destination = smb_nbns; addr_num = nbns_num; retries = UCAST_REQ_RETRY_COUNT; timeout = UCAST_REQ_RETRY_TIMEOUT; packet.info = NAME_QUERY_REQUEST | NM_FLAGS_UNICAST; } packet.qdcount = 1; /* question entries */ packet.question = question; packet.ancount = 0; /* answer recs */ packet.answer = NULL; packet.nscount = 0; /* authority recs */ packet.authority = NULL; packet.arcount = 0; /* additional recs */ packet.additional = NULL; for (i = 0; i < addr_num; i++) { for (retry = 0; retry < retries; retry++) { if ((destination[i].flags & ADDR_FLAG_VALID) == 0) break; tid = smb_netbios_name_trn_id(); packet.name_trn_id = tid; if (smb_send_name_service_packet(&destination[i], &packet) >= 0) { if ((rc = smb_netbios_process_response(tid, &destination[i], &packet, timeout)) != 0) break; } st.tv_sec = 0; st.tv_nsec = (timeout * 1000000); (void) nanosleep(&st, 0); } } return (rc); } /* * RFC 1002 4.2.13. POSITIVE NAME QUERY RESPONSE * RFC 1002 4.2.14. NEGATIVE NAME QUERY RESPONSE */ static int smb_send_name_query_response(addr_entry_t *addr, struct name_packet *original_packet, struct name_entry *entry, uint16_t rcode) { addr_entry_t *raddr; struct name_packet packet; struct resource_record answer; uint16_t attr; unsigned char data[MAX_DATAGRAM_LENGTH]; unsigned char *scan = data; uint32_t ret_addr; packet.name_trn_id = original_packet->name_trn_id; packet.info = NAME_QUERY_RESPONSE | (rcode & NAME_RCODE_MASK); packet.qdcount = 0; /* question entries */ packet.question = NULL; packet.ancount = 1; /* answer recs */ packet.answer = &answer; packet.nscount = 0; /* authority recs */ packet.authority = NULL; packet.arcount = 0; /* additional recs */ packet.additional = NULL; answer.name = entry; answer.rr_class = NAME_QUESTION_CLASS_IN; answer.ttl = entry->addr_list.ttl; answer.rdata = data; if (rcode) { answer.rr_type = NAME_RR_TYPE_NULL; answer.rdlength = 0; bzero(data, 6); } else { answer.rdlength = 0; answer.rr_type = NAME_QUESTION_TYPE_NB; raddr = &entry->addr_list; scan = data; do { attr = entry->attributes & (NAME_ATTR_GROUP | NAME_ATTR_OWNER_NODE_TYPE); BE_OUT16(scan, attr); scan += 2; ret_addr = LE_32(raddr->sin.sin_addr.s_addr); *scan++ = ret_addr; *scan++ = ret_addr >> 8; *scan++ = ret_addr >> 16; *scan++ = ret_addr >> 24; answer.rdlength += 6; raddr = raddr->forw; } while (raddr != &entry->addr_list); } return (smb_send_name_service_packet(addr, &packet)); } /* * RFC 1002 4.2.18. NODE STATUS RESPONSE */ static int smb_send_node_status_response(addr_entry_t *addr, struct name_packet *original_packet) { uint32_t net_ipaddr; int64_t max_connections; struct arpreq arpreq; struct name_packet packet; struct resource_record answer; unsigned char *scan; unsigned char *scan_end; unsigned char data[MAX_NETBIOS_REPLY_DATA_SIZE]; boolean_t scan_done = B_FALSE; smb_inaddr_t ipaddr; bzero(&packet, sizeof (struct name_packet)); bzero(&answer, sizeof (struct resource_record)); packet.name_trn_id = original_packet->name_trn_id; packet.info = NODE_STATUS_RESPONSE; packet.qdcount = 0; /* question entries */ packet.question = NULL; packet.ancount = 1; /* answer recs */ packet.answer = &answer; packet.nscount = 0; /* authority recs */ packet.authority = NULL; packet.arcount = 0; /* additional recs */ packet.additional = NULL; answer.name = original_packet->question->name; answer.rr_type = NAME_RR_TYPE_NBSTAT; answer.rr_class = NAME_QUESTION_CLASS_IN; answer.ttl = 0; answer.rdata = data; scan = smb_netbios_cache_status(data, MAX_NETBIOS_REPLY_DATA_SIZE, original_packet->question->name->scope); scan_end = data + MAX_NETBIOS_REPLY_DATA_SIZE; ipaddr.a_ipv4 = addr->sin.sin_addr.s_addr; ipaddr.a_family = AF_INET; if (smb_nic_is_same_subnet(&ipaddr)) net_ipaddr = addr->sin.sin_addr.s_addr; else net_ipaddr = 0; (void) smb_config_getnum(SMB_CI_MAX_CONNECTIONS, &max_connections); while (!scan_done) { if ((scan + 6) >= scan_end) { packet.info |= NAME_NM_FLAGS_TC; break; } if (net_ipaddr != 0) { struct sockaddr_in *s_in; int s; s = socket(AF_INET, SOCK_DGRAM, 0); /* LINTED - E_BAD_PTR_CAST_ALIGN */ s_in = (struct sockaddr_in *)&arpreq.arp_pa; s_in->sin_family = AF_INET; s_in->sin_addr.s_addr = net_ipaddr; if (ioctl(s, SIOCGARP, (caddr_t)&arpreq) < 0) { bzero(scan, 6); } else { bcopy(&arpreq.arp_ha.sa_data, scan, 6); } (void) close(s); } else { bzero(scan, 6); } scan += 6; if ((scan + 26) >= scan_end) { packet.info |= NAME_NM_FLAGS_TC; break; } bzero(scan, 26); scan += 26; if ((scan + 2) >= scan_end) { packet.info |= NAME_NM_FLAGS_TC; break; } BE_OUT16(scan, 0); scan += 2; if ((scan + 2) >= scan_end) { packet.info |= NAME_NM_FLAGS_TC; break; } BE_OUT16(scan, 0); scan += 2; if ((scan + 2) >= scan_end) { packet.info |= NAME_NM_FLAGS_TC; break; } BE_OUT16(scan, 0); scan += 2; if ((scan + 2) >= scan_end) { packet.info |= NAME_NM_FLAGS_TC; break; } BE_OUT16(scan, 0); scan += 2; if ((scan + 2) >= scan_end) { packet.info |= NAME_NM_FLAGS_TC; break; } BE_OUT16(scan, 0); scan += 2; if ((scan + 2) >= scan_end) { packet.info |= NAME_NM_FLAGS_TC; break; } BE_OUT16(scan, 0); scan += 2; if ((scan + 2) >= scan_end) { packet.info |= NAME_NM_FLAGS_TC; break; } BE_OUT16(scan, 0); scan += 2; if ((scan + 2) >= scan_end) { packet.info |= NAME_NM_FLAGS_TC; break; } BE_OUT16(scan, max_connections); scan += 2; if ((scan + 2) >= scan_end) { packet.info |= NAME_NM_FLAGS_TC; break; } BE_OUT16(scan, 0); scan += 2; scan_done = B_TRUE; } answer.rdlength = scan - data; return (smb_send_name_service_packet(addr, &packet)); } static int smb_name_Bnode_add_name(struct name_entry *name) { struct name_question question; struct resource_record additional; unsigned char data[8]; uint16_t attr; addr_entry_t *addr; int rc = 0; addr = &name->addr_list; do { /* build name service packet */ question.name = name; /* * question.name->attributes |= NAME_NB_FLAGS_ONT_B; * This is commented because NAME_NB_FLAGS_ONT_B is 0 */ question.question_type = NAME_QUESTION_TYPE_NB; question.question_class = NAME_QUESTION_CLASS_IN; additional.name = name; additional.rr_class = NAME_QUESTION_CLASS_IN; additional.ttl = 0; additional.rdata = data; additional.rdlength = 6; additional.rr_type = NAME_QUESTION_TYPE_NB; attr = name->attributes & (NAME_ATTR_GROUP | NAME_ATTR_OWNER_NODE_TYPE); BE_OUT16(&data[0], attr); (void) memcpy(&data[2], &addr->sin.sin_addr.s_addr, sizeof (uint32_t)); rc |= smb_send_name_registration_request(BROADCAST, &question, &additional); addr = addr->forw; } while (addr != &name->addr_list); return (rc); } static int smb_name_Bnode_find_name(struct name_entry *name) { struct name_question question; question.name = name; question.question_type = NAME_QUESTION_TYPE_NB; question.question_class = NAME_QUESTION_CLASS_IN; return (smb_send_name_query_request(BROADCAST, &question)); } static int smb_name_Bnode_delete_name(struct name_entry *name) { struct name_question question; struct resource_record additional; addr_entry_t *raddr; unsigned char data[MAX_DATAGRAM_LENGTH]; unsigned char *scan = data; uint32_t attr; uint32_t ret_addr; /* build packet */ question.name = name; question.question_type = NAME_QUESTION_TYPE_NB; question.question_class = NAME_QUESTION_CLASS_IN; additional.name = name; additional.rr_class = NAME_QUESTION_CLASS_IN; additional.ttl = 0; additional.rdata = data; additional.rdlength = 0; additional.rr_type = NAME_QUESTION_TYPE_NB; raddr = &name->addr_list; scan = data; do { attr = name->attributes & (NAME_ATTR_GROUP | NAME_ATTR_OWNER_NODE_TYPE); BE_OUT16(scan, attr); scan += 2; ret_addr = LE_32(raddr->sin.sin_addr.s_addr); *scan++ = ret_addr; *scan++ = ret_addr >> 8; *scan++ = ret_addr >> 16; *scan++ = ret_addr >> 24; additional.rdlength += 6; } while (raddr != &name->addr_list); return (smb_send_name_release_request_and_demand(BROADCAST, &question, &additional)); } static int smb_name_Pnode_add_name(struct name_entry *name) { struct name_question question; struct resource_record additional; unsigned char data[8]; uint16_t attr; addr_entry_t *addr; int rc = 0; /* build packet */ addr = &name->addr_list; do { question.name = name; question.question_type = NAME_QUESTION_TYPE_NB; question.question_class = NAME_QUESTION_CLASS_IN; additional.name = name; additional.rr_class = NAME_QUESTION_CLASS_IN; additional.ttl = 0; additional.rdata = data; additional.rdlength = 6; additional.rr_type = NAME_QUESTION_TYPE_NB; attr = name->attributes & (NAME_ATTR_GROUP | NAME_ATTR_OWNER_NODE_TYPE); BE_OUT16(&data[0], attr); (void) memcpy(&data[2], &addr->sin.sin_addr.s_addr, sizeof (uint32_t)); rc |= smb_send_name_registration_request(UNICAST, &question, &additional); addr = addr->forw; } while (addr != &name->addr_list); return (rc); } static int smb_name_Pnode_refresh_name(struct name_entry *name) { struct name_question question; struct resource_record additional; unsigned char data[8]; uint16_t attr; addr_entry_t *addr; int rc = 0; /* build packet */ addr = &name->addr_list; do { question.name = name; question.question_type = NAME_QUESTION_TYPE_NB; question.question_class = NAME_QUESTION_CLASS_IN; additional.name = name; additional.rr_class = NAME_QUESTION_CLASS_IN; additional.ttl = 0; additional.rdata = data; additional.rdlength = 6; additional.rr_type = NAME_QUESTION_TYPE_NB; attr = name->attributes & (NAME_ATTR_GROUP | NAME_ATTR_OWNER_NODE_TYPE); BE_OUT16(&data[0], attr); (void) memcpy(&data[2], &addr->sin.sin_addr.s_addr, sizeof (uint32_t)); rc |= smb_send_name_refresh_request(UNICAST, &question, &additional, 1); addr = addr->forw; } while (addr != &name->addr_list); return (rc); } static int smb_name_Pnode_find_name(struct name_entry *name) { struct name_question question; /* * Host initiated processing for a P node */ question.name = name; question.name->attributes |= NAME_NB_FLAGS_ONT_P; question.question_type = NAME_QUESTION_TYPE_NB; question.question_class = NAME_QUESTION_CLASS_IN; return (smb_send_name_query_request(UNICAST, &question)); } static int smb_name_Pnode_delete_name(struct name_entry *name) { struct name_question question; struct resource_record additional; addr_entry_t *raddr; unsigned char data[MAX_DATAGRAM_LENGTH]; unsigned char *scan = data; uint32_t attr; uint32_t ret_addr; /* build packet */ question.name = name; question.name->attributes |= NAME_NB_FLAGS_ONT_P; question.question_type = NAME_QUESTION_TYPE_NB; question.question_class = NAME_QUESTION_CLASS_IN; additional.name = name; additional.rr_class = NAME_QUESTION_CLASS_IN; additional.ttl = 0; additional.rdata = data; additional.rdlength = 0; additional.rr_type = NAME_QUESTION_TYPE_NB; raddr = &name->addr_list; do { scan = data; attr = name->attributes & (NAME_ATTR_GROUP | NAME_ATTR_OWNER_NODE_TYPE); BE_OUT16(scan, attr); scan += 2; ret_addr = LE_32(raddr->sin.sin_addr.s_addr); *scan++ = ret_addr; *scan++ = ret_addr >> 8; *scan++ = ret_addr >> 16; *scan++ = ret_addr >> 24; additional.rdlength = 6; raddr = raddr->forw; (void) smb_send_name_release_request_and_demand(UNICAST, &question, &additional); } while (raddr != &name->addr_list); return (1); } static int smb_name_Mnode_add_name(struct name_entry *name) { if (smb_name_Bnode_add_name(name) > 0) { if (nbns_num == 0) return (1); /* No name server configured */ return (smb_name_Pnode_add_name(name)); } return (-1); } static int smb_name_Hnode_add_name(struct name_entry *name) { if (nbns_num > 0) { if (smb_name_Pnode_add_name(name) == 1) return (1); } return (smb_name_Bnode_add_name(name)); } static int smb_name_Mnode_find_name(struct name_entry *name) { if (smb_name_Bnode_find_name(name) == 1) return (1); if (nbns_num == 0) return (1); /* No name server configured */ return (smb_name_Pnode_find_name(name)); } static int smb_name_Hnode_find_name(struct name_entry *name) { if (nbns_num > 0) if (smb_name_Pnode_find_name(name) == 1) return (1); return (smb_name_Bnode_find_name(name)); } static int smb_name_Mnode_delete_name(struct name_entry *name) { (void) smb_name_Bnode_delete_name(name); if (nbns_num == 0) return (-1); /* No name server configured */ if (smb_name_Pnode_delete_name(name) > 0) return (1); return (-1); } static int smb_name_Hnode_delete_name(struct name_entry *name) { if (nbns_num > 0) if (smb_name_Pnode_delete_name(name) > 0) return (1); return (smb_name_Bnode_delete_name(name)); } static void smb_name_process_Bnode_packet(struct name_packet *packet, addr_entry_t *addr) { struct name_entry *name; struct name_entry *entry; struct name_question *question; struct resource_record *additional; question = packet->question; additional = packet->additional; switch (packet->info & NAME_OPCODE_OPCODE_MASK) { case NAME_OPCODE_REFRESH: /* Guard against malformed packets */ if ((question == 0) || (additional == 0)) break; if (additional->name->addr_list.sin.sin_addr.s_addr == 0) break; name = question->name; name->addr_list.ttl = additional->ttl; name->attributes = additional->name->attributes; name->addr_list.sin = additional->name->addr_list.sin; name->addr_list.forw = name->addr_list.back = &name->addr_list; if ((entry = smb_netbios_cache_lookup_addr(name)) != 0) { smb_netbios_cache_update_entry(entry, question->name); smb_netbios_cache_unlock_entry(entry); } else (void) smb_netbios_cache_insert(question->name); break; case NAME_OPCODE_QUERY: /* * This opcode covers both NAME_QUERY_REQUEST and * NODE_STATUS_REQUEST. They can be distinguished * based on the type of question entry. */ /* All query requests have to have question entry */ if (question == 0) break; if (question->question_type == NAME_QUESTION_TYPE_NB) { name = question->name; if ((entry = smb_netbios_cache_lookup(name)) != 0) { (void) smb_send_name_query_response(addr, packet, entry, 0); smb_netbios_cache_unlock_entry(entry); } } else if (question->question_type == NAME_QUESTION_TYPE_NBSTAT) { /* * Name of "*" may be used to force node to * divulge status for administrative purposes */ name = question->name; entry = 0; if (NETBIOS_NAME_IS_STAR(name->name) || ((entry = smb_netbios_cache_lookup(name)) != 0)) { if (entry) smb_netbios_cache_unlock_entry(entry); /* * send only those names that are * in the same scope as the scope * field in the request packet */ (void) smb_send_node_status_response(addr, packet); } } break; default: break; } } static void smb_name_process_Pnode_packet(struct name_packet *packet, addr_entry_t *addr) { struct name_entry *name; struct name_entry *entry; struct name_question *question; struct resource_record *additional; question = packet->question; additional = packet->additional; if (packet->info & NAME_NM_FLAGS_B) { /* * always ignore UDP broadcast packets */ return; } switch (packet->info & NAME_OPCODE_OPCODE_MASK) { case NAME_OPCODE_REFRESH: /* Guard against malformed packets */ if ((question == 0) || (additional == 0)) break; if (additional->name->addr_list.sin.sin_addr.s_addr == 0) break; name = question->name; name->addr_list.ttl = additional->ttl; name->attributes = additional->name->attributes; name->addr_list.sin = additional->name->addr_list.sin; name->addr_list.forw = name->addr_list.back = &name->addr_list; if ((entry = smb_netbios_cache_lookup(name)) != 0) { smb_netbios_cache_update_entry(entry, name); smb_netbios_cache_unlock_entry(entry); } else (void) smb_netbios_cache_insert(name); (void) smb_send_name_registration_response(addr, packet, 0); break; case NAME_OPCODE_QUERY: /* * This opcode covers both NAME_QUERY_REQUEST and * NODE_STATUS_REQUEST. They can be distinguished * based on the type of question entry. */ /* All query requests have to have question entry */ if (question == 0) break; if (question->question_type == NAME_QUESTION_TYPE_NB) { name = question->name; if ((entry = smb_netbios_cache_lookup(name)) != 0) { /* * send response to the IP address and port * number from which the request was received. */ (void) smb_send_name_query_response(addr, packet, entry, 0); smb_netbios_cache_unlock_entry(entry); } else { /* * send response to the requestor */ (void) smb_send_name_query_response(addr, packet, name, RCODE_NAM_ERR); } } else if (question->question_type == NAME_QUESTION_TYPE_NBSTAT) { /* * Name of "*" may be used to force node to * divulge status for administrative purposes */ name = question->name; entry = 0; if (NETBIOS_NAME_IS_STAR(name->name) || ((entry = smb_netbios_cache_lookup(name)) != 0)) { /* * send only those names that are * in the same scope as the scope * field in the request packet */ if (entry) smb_netbios_cache_unlock_entry(entry); (void) smb_send_node_status_response(addr, packet); } } break; default: break; } } static void smb_name_process_Mnode_packet(struct name_packet *packet, addr_entry_t *addr) { if (packet->info & NAME_NM_FLAGS_B) smb_name_process_Bnode_packet(packet, addr); else smb_name_process_Pnode_packet(packet, addr); } static void smb_name_process_Hnode_packet(struct name_packet *packet, addr_entry_t *addr) { if (packet->info & NAME_NM_FLAGS_B) smb_name_process_Bnode_packet(packet, addr); else smb_name_process_Pnode_packet(packet, addr); } /* * smb_netbios_name_tick * * Called once a second to handle name server timeouts. */ void smb_netbios_name_tick(void) { struct name_entry *name; struct name_entry *entry; (void) mutex_lock(&refresh_queue.mtx); smb_netbios_cache_refresh(&refresh_queue); while ((name = refresh_queue.head.forw) != &refresh_queue.head) { QUEUE_CLIP(name); if (IS_LOCAL(name->attributes)) { if (IS_UNIQUE(name->attributes)) { (void) smb_name_Pnode_refresh_name(name); } } else { entry = smb_name_find_name(name); smb_name_unlock_name(entry); } free(name); } (void) mutex_unlock(&refresh_queue.mtx); smb_netbios_cache_reset_ttl(); } /* * smb_name_find_name * * Lookup name cache for the given name. * If it's not in the cache it'll send a * name query request and then lookup the * cache again. Note that if a name is * returned it's locked and called MUST * unlock it by calling smb_name_unlock_name() */ struct name_entry * smb_name_find_name(struct name_entry *name) { struct name_entry *result; if ((result = smb_netbios_cache_lookup(name)) == 0) { switch (smb_node_type) { case 'B': (void) smb_name_Bnode_find_name(name); break; case 'P': (void) smb_name_Pnode_find_name(name); break; case 'M': (void) smb_name_Mnode_find_name(name); break; case 'H': default: (void) smb_name_Hnode_find_name(name); break; } return (smb_netbios_cache_lookup(name)); } return (result); } void smb_name_unlock_name(struct name_entry *name) { smb_netbios_cache_unlock_entry(name); } int smb_name_add_name(struct name_entry *name) { int rc = 1; smb_netbios_name_logf(name); switch (smb_node_type) { case 'B': rc = smb_name_Bnode_add_name(name); break; case 'P': rc = smb_name_Pnode_add_name(name); break; case 'M': rc = smb_name_Mnode_add_name(name); break; case 'H': default: rc = smb_name_Hnode_add_name(name); break; } if (rc >= 0) (void) smb_netbios_cache_insert(name); return (rc); } int smb_name_delete_name(struct name_entry *name) { int rc; unsigned char type; type = name->name[15]; if ((type != NBT_WKSTA) && (type != NBT_SERVER)) { syslog(LOG_DEBUG, "nbns: name delete bad type (0x%02x)", type); smb_netbios_name_logf(name); name->attributes &= ~NAME_ATTR_LOCAL; return (-1); } smb_netbios_cache_delete(name); switch (smb_node_type) { case 'B': rc = smb_name_Bnode_delete_name(name); break; case 'P': rc = smb_name_Pnode_delete_name(name); break; case 'M': rc = smb_name_Mnode_delete_name(name); break; case 'H': default: rc = smb_name_Hnode_delete_name(name); break; } if (rc > 0) return (0); return (-1); } typedef struct { addr_entry_t *addr; char *buf; int length; } worker_param_t; /* * smb_netbios_worker * * Process incoming request/response packets for Netbios * name service (on port 138). */ void * smb_netbios_worker(void *arg) { worker_param_t *p = (worker_param_t *)arg; addr_entry_t *addr = p->addr; struct name_packet *packet; if ((packet = smb_name_buf_to_packet(p->buf, p->length)) != NULL) { if (packet->info & NAME_OPCODE_R) { /* Reply packet */ smb_reply_ready(packet, addr); free(p->buf); free(p); return (NULL); } /* Request packet */ switch (smb_node_type) { case 'B': smb_name_process_Bnode_packet(packet, addr); break; case 'P': smb_name_process_Pnode_packet(packet, addr); break; case 'M': smb_name_process_Mnode_packet(packet, addr); break; case 'H': default: smb_name_process_Hnode_packet(packet, addr); break; } if (packet->answer) smb_netbios_name_freeaddrs(packet->answer->name); free(packet); } else { syslog(LOG_ERR, "nbns: packet decode failed"); } free(addr); free(p->buf); free(p); return (NULL); } /* * Configure the node type. If a WINS server has been specified, * act like an H-node. Otherwise, behave like a B-node. */ static void smb_netbios_node_config(void) { static smb_cfg_id_t wins[SMB_PI_MAX_WINS] = { SMB_CI_WINS_SRV1, SMB_CI_WINS_SRV2 }; char ipstr[16]; uint32_t ipaddr; int i; smb_node_type = SMB_NODETYPE_B; nbns_num = 0; bzero(smb_nbns, sizeof (addr_entry_t) * SMB_PI_MAX_WINS); for (i = 0; i < SMB_PI_MAX_WINS; ++i) { ipstr[0] = '\0'; (void) smb_config_getstr(wins[i], ipstr, sizeof (ipstr)); if ((ipaddr = inet_addr(ipstr)) == INADDR_NONE) continue; smb_node_type = SMB_NODETYPE_H; smb_nbns[nbns_num].flags = ADDR_FLAG_VALID; smb_nbns[nbns_num].sinlen = sizeof (struct sockaddr_in); smb_nbns[nbns_num].sin.sin_family = AF_INET; smb_nbns[nbns_num].sin.sin_addr.s_addr = ipaddr; smb_nbns[nbns_num].sin.sin_port = htons(IPPORT_NETBIOS_NS); nbns_num++; } } static void smb_netbios_name_registration(void) { nbcache_iter_t nbc_iter; struct name_entry *name; int rc; rc = smb_netbios_cache_getfirst(&nbc_iter); while (rc == 0) { name = nbc_iter.nbc_entry; (void) smb_netbios_name_logf(name); if (IS_UNIQUE(name->attributes) && IS_LOCAL(name->attributes)) { switch (smb_node_type) { case SMB_NODETYPE_B: (void) smb_name_Bnode_add_name(name); break; case SMB_NODETYPE_P: (void) smb_name_Pnode_add_name(name); break; case SMB_NODETYPE_M: (void) smb_name_Mnode_add_name(name); break; case SMB_NODETYPE_H: default: (void) smb_name_Hnode_add_name(name); break; } } free(name); rc = smb_netbios_cache_getnext(&nbc_iter); } } /* * Note that the node configuration must be setup before calling * smb_init_name_struct(). */ void smb_netbios_name_config(void) { addr_entry_t *bcast_entry; struct name_entry name; smb_niciter_t ni; int rc; (void) mutex_lock(&nbt_name_config_mtx); smb_netbios_node_config(); bcast_num = 0; bzero(smb_bcast_list, sizeof (addr_entry_t) * SMB_PI_MAX_NETWORKS); rc = smb_nic_getfirst(&ni); while (rc == SMB_NIC_SUCCESS) { if ((ni.ni_nic.nic_smbflags & SMB_NICF_NBEXCL) || (ni.ni_nic.nic_smbflags & SMB_NICF_ALIAS)) { rc = smb_nic_getnext(&ni); continue; } bcast_entry = &smb_bcast_list[bcast_num]; bcast_entry->flags = ADDR_FLAG_VALID; bcast_entry->attributes = NAME_ATTR_LOCAL; bcast_entry->sinlen = sizeof (struct sockaddr_in); bcast_entry->sin.sin_family = AF_INET; bcast_entry->sin.sin_port = htons(IPPORT_NETBIOS_NS); bcast_entry->sin.sin_addr.s_addr = ni.ni_nic.nic_bcast; bcast_num++; smb_init_name_struct((unsigned char *)ni.ni_nic.nic_host, NBT_WKSTA, 0, ni.ni_nic.nic_ip.a_ipv4, htons(IPPORT_NETBIOS_DGM), NAME_ATTR_UNIQUE, NAME_ATTR_LOCAL, &name); (void) smb_netbios_cache_insert(&name); smb_init_name_struct((unsigned char *)ni.ni_nic.nic_host, NBT_SERVER, 0, ni.ni_nic.nic_ip.a_ipv4, htons(IPPORT_NETBIOS_DGM), NAME_ATTR_UNIQUE, NAME_ATTR_LOCAL, &name); (void) smb_netbios_cache_insert(&name); rc = smb_nic_getnext(&ni); } smb_netbios_name_registration(); (void) mutex_unlock(&nbt_name_config_mtx); } void smb_netbios_name_unconfig(void) { struct name_entry *name; (void) mutex_lock(&nbt_name_config_mtx); (void) mutex_lock(&delete_queue.mtx); smb_netbios_cache_delete_locals(&delete_queue); while ((name = delete_queue.head.forw) != &delete_queue.head) { QUEUE_CLIP(name); (void) smb_name_delete_name(name); free(name); } (void) mutex_unlock(&delete_queue.mtx); (void) mutex_unlock(&nbt_name_config_mtx); } void smb_netbios_name_reconfig(void) { smb_netbios_name_unconfig(); smb_netbios_name_config(); } /* * NetBIOS Name Service (port 137) */ /*ARGSUSED*/ void * smb_netbios_name_service(void *arg) { struct sockaddr_in sin; addr_entry_t *addr; int len; int flag = 1; char *buf; worker_param_t *worker_param; smb_inaddr_t ipaddr; /* * Initialize reply_queue */ bzero(&reply_queue, sizeof (reply_queue)); reply_queue.forw = reply_queue.back = &reply_queue; if ((name_sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { syslog(LOG_ERR, "nbns: socket failed: %m"); smb_netbios_event(NETBIOS_EVENT_ERROR); return (NULL); } flag = 1; (void) setsockopt(name_sock, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof (flag)); flag = 1; (void) setsockopt(name_sock, SOL_SOCKET, SO_BROADCAST, &flag, sizeof (flag)); bzero(&sin, sizeof (struct sockaddr_in)); sin.sin_family = AF_INET; sin.sin_port = htons(IPPORT_NETBIOS_NS); if (bind(name_sock, (struct sockaddr *)&sin, sizeof (sin)) != 0) { syslog(LOG_ERR, "nbns: bind(%d) failed: %m", IPPORT_NETBIOS_NS); (void) close(name_sock); smb_netbios_event(NETBIOS_EVENT_ERROR); return (NULL); } smb_netbios_event(NETBIOS_EVENT_NS_START); while (smb_netbios_running()) { buf = malloc(MAX_DATAGRAM_LENGTH); addr = malloc(sizeof (addr_entry_t)); if ((buf == NULL) || (addr == NULL)) { /* Sleep for 10 seconds and try again */ free(addr); free(buf); smb_netbios_sleep(10); continue; } ignore: bzero(addr, sizeof (addr_entry_t)); addr->sinlen = sizeof (addr->sin); addr->forw = addr->back = addr; if ((len = recvfrom(name_sock, buf, MAX_DATAGRAM_LENGTH, 0, (struct sockaddr *)&addr->sin, &addr->sinlen)) < 0) { if (errno == ENOMEM || errno == ENFILE || errno == EMFILE) { /* Sleep for 10 seconds and try again */ free(buf); free(addr); smb_netbios_sleep(10); continue; } syslog(LOG_ERR, "nbns: recvfrom failed: %m"); free(buf); free(addr); smb_netbios_event(NETBIOS_EVENT_ERROR); goto shutdown; } /* Ignore any incoming packets from myself... */ ipaddr.a_ipv4 = addr->sin.sin_addr.s_addr; ipaddr.a_family = AF_INET; if (smb_nic_is_local(&ipaddr)) goto ignore; /* * Launch a netbios worker to process the received packet. */ worker_param = malloc(sizeof (worker_param_t)); if (worker_param) { pthread_t worker; pthread_attr_t tattr; worker_param->addr = addr; worker_param->buf = buf; worker_param->length = len; (void) pthread_attr_init(&tattr); (void) pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED); (void) pthread_create(&worker, &tattr, smb_netbios_worker, worker_param); (void) pthread_attr_destroy(&tattr); } } shutdown: smb_netbios_event(NETBIOS_EVENT_NS_STOP); smb_netbios_wait(NETBIOS_EVENT_BROWSER_STOP); if (!smb_netbios_error()) smb_netbios_name_unconfig(); (void) close(name_sock); return (NULL); }