static bool query_one(const char *lookup, unsigned int lookup_type) { int j, count; uint8_t flags; struct sockaddr_storage *ip_list=NULL; NTSTATUS status = NT_STATUS_NOT_FOUND; if (got_bcast) { char addr[INET6_ADDRSTRLEN]; print_sockaddr(addr, sizeof(addr), &bcast_addr); d_printf("querying %s on %s\n", lookup, addr); status = name_query(lookup,lookup_type,use_bcast, use_bcast?true:recursion_desired, &bcast_addr, talloc_tos(), &ip_list, &count, &flags); } else { status = name_resolve_bcast( lookup, lookup_type, talloc_tos(), &ip_list, &count); } if (!NT_STATUS_IS_OK(status)) { return false; } if (give_flags) { d_printf("Flags: %s\n", query_flags(flags)); } for (j=0;j<count;j++) { char addr[INET6_ADDRSTRLEN]; if (translate_addresses) { char h_name[MAX_DNS_NAME_LENGTH]; h_name[0] = '\0'; if (sys_getnameinfo((const struct sockaddr *)&ip_list[j], sizeof(struct sockaddr_storage), h_name, sizeof(h_name), NULL, 0, NI_NAMEREQD)) { continue; } d_printf("%s, ", h_name); } print_sockaddr(addr, sizeof(addr), &ip_list[j]); d_printf("%s %s<%02x>\n", addr,lookup, lookup_type); /* We can only do find_status if the ip address returned was valid - ie. name_query returned true. */ if (find_status) { if (!do_node_status(lookup, lookup_type, &ip_list[j])) { status = NT_STATUS_UNSUCCESSFUL; } } } TALLOC_FREE(ip_list); return NT_STATUS_IS_OK(status); }
static void print_cmsg_ip_recverr(struct tcb *tcp, const void *cmsg_data, const size_t data_len) { const struct { uint32_t ee_errno; uint8_t ee_origin; uint8_t ee_type; uint8_t ee_code; uint8_t ee_pad; uint32_t ee_info; uint32_t ee_data; struct sockaddr_in offender; } *err = cmsg_data; if (sizeof(*err) > data_len) return; tprintf(", {ee_errno=%u, ee_origin=%u, ee_type=%u, ee_code=%u" ", ee_info=%u, ee_data=%u, offender=", err->ee_errno, err->ee_origin, err->ee_type, err->ee_code, err->ee_info, err->ee_data); print_sockaddr(tcp, (const void *) &err->offender, sizeof(err->offender)); tprints("}"); }
static int net_lookup_pdc(struct net_context *c, int argc, const char **argv) { struct sockaddr_storage ss; char *pdc_str = NULL; const char *domain; char addr[INET6_ADDRSTRLEN]; if (lp_security() == SEC_ADS) { domain = lp_realm(); } else { domain = c->opt_target_workgroup; } if (argc > 0) domain=argv[0]; /* first get PDC */ if (!get_pdc_ip(domain, &ss)) return -1; print_sockaddr(addr, sizeof(addr), &ss); if (asprintf(&pdc_str, "%s", addr) == -1) { return -1; } d_printf("%s\n", pdc_str); SAFE_FREE(pdc_str); return 0; }
/* lookup a hostname giving an IP */ static int net_lookup_host(struct net_context *c, int argc, const char **argv) { struct sockaddr_storage ss; int name_type = 0x20; char addr[INET6_ADDRSTRLEN]; const char *name = argv[0]; char *p; if (argc == 0) return net_lookup_usage(c, argc, argv); p = strchr_m(name,'#'); if (p) { *p = '\0'; sscanf(++p,"%x",&name_type); } if (!resolve_name(name, &ss, name_type, false)) { /* we deliberately use DEBUG() here to send it to stderr so scripts aren't mucked up */ DEBUG(0,("Didn't find %s#%02x\n", name, name_type)); return -1; } print_sockaddr(addr, sizeof(addr), &ss); d_printf("%s\n", addr); return 0; }
int main(int argc, char const* argv[]) { if (argc<2) perr("usage: chat_server [port]"); struct addrinfo *plist = get_addrinfo_list("localhost",argv[1],SOCK_STREAM); int fd = try_bind(plist); if (fd==-1) perr("Cannot bind socket to port"); freeaddrinfo(plist); if (listen(fd,BACKLOG)==-1) { perror("listen"); exit(1); } struct sigaction sa; sa.sa_handler = sigchld_handler; sa.sa_flags = SA_RESTART; sigemptyset(&sa.sa_mask); if (sigaction(SIGCHLD,&sa,NULL)==-1) { perror("sigaction"); exit(1); } while(1) { struct sockaddr_storage addr; socklen_t addr_len; int client_fd = accept(fd,(struct sockaddr *)&addr,&addr_len); if (fd==-1) { perror("accept"); exit(1); } fprintf(stderr,"Got connection from\n"); print_sockaddr((struct sockaddr*)&addr); fprintf(stderr,"\n"); int pid=fork(); if (pid<0) { perror("fork"); exit(1); } else if (pid==0) { // child close(fd); const char welcome[] = "Welcome!"; //write(client_fd,welcome,sizeof(welcome)); struct client_mgr_t args={client_fd,60.0}; server_recvmgr(&args); close(client_fd); exit(0); } // parent close(client_fd); } return 0; }
static NTSTATUS discover_dc_netbios(TALLOC_CTX *mem_ctx, const char *domain_name, uint32_t flags, struct ip_service_name **returned_dclist, int *returned_count) { NTSTATUS status; enum nbt_name_type name_type = NBT_NAME_LOGON; struct ip_service *iplist; int i; struct ip_service_name *dclist = NULL; int count; *returned_dclist = NULL; *returned_count = 0; if (lp_disable_netbios()) { return NT_STATUS_NOT_SUPPORTED; } if (flags & DS_PDC_REQUIRED) { name_type = NBT_NAME_PDC; } status = internal_resolve_name(domain_name, name_type, NULL, &iplist, &count, "lmhosts wins bcast"); if (!NT_STATUS_IS_OK(status)) { DEBUG(10,("discover_dc_netbios: failed to find DC\n")); return status; } dclist = TALLOC_ZERO_ARRAY(mem_ctx, struct ip_service_name, count); if (!dclist) { return NT_STATUS_NO_MEMORY; } for (i=0; i<count; i++) { char addr[INET6_ADDRSTRLEN]; struct ip_service_name *r = &dclist[i]; print_sockaddr(addr, sizeof(addr), &iplist[i].ss); r->ss = iplist[i].ss; r->port = iplist[i].port; r->hostname = talloc_strdup(mem_ctx, addr); if (!r->hostname) { return NT_STATUS_NO_MEMORY; } } *returned_dclist = dclist; *returned_count = count; return NT_STATUS_OK; }
static NTSTATUS make_dc_info_from_cldap_reply(TALLOC_CTX *mem_ctx, uint32_t flags, struct sockaddr_storage *ss, struct NETLOGON_SAM_LOGON_RESPONSE_EX *r, struct netr_DsRGetDCNameInfo **info) { const char *dc_hostname = NULL; const char *dc_domain_name = NULL; const char *dc_address = NULL; const char *dc_forest = NULL; uint32_t dc_address_type = 0; uint32_t dc_flags = 0; struct GUID *dc_domain_guid = NULL; const char *dc_server_site = NULL; const char *dc_client_site = NULL; char addr[INET6_ADDRSTRLEN]; if (ss) { print_sockaddr(addr, sizeof(addr), ss); dc_address = addr; dc_address_type = DS_ADDRESS_TYPE_INET; } if (!ss && r->sockaddr.pdc_ip) { dc_address = r->sockaddr.pdc_ip; dc_address_type = DS_ADDRESS_TYPE_INET; } else { dc_address = r->pdc_name; dc_address_type = DS_ADDRESS_TYPE_NETBIOS; } map_dc_and_domain_names(flags, r->pdc_name, r->domain, r->pdc_dns_name, r->dns_domain, &dc_flags, &dc_hostname, &dc_domain_name); dc_flags |= r->server_type; dc_forest = r->forest; dc_domain_guid = &r->domain_uuid; dc_server_site = r->server_site; dc_client_site = r->client_site; return make_domain_controller_info(mem_ctx, dc_hostname, dc_address, dc_address_type, dc_domain_guid, dc_domain_name, dc_forest, dc_flags, dc_server_site, dc_client_site, info); }
static int net_lookup_dc(struct net_context *c, int argc, const char **argv) { struct ip_service *ip_list; struct sockaddr_storage ss; char *pdc_str = NULL; const char *domain = NULL; char *sitename = NULL; int count, i; char addr[INET6_ADDRSTRLEN]; bool sec_ads = (lp_security() == SEC_ADS); if (sec_ads) { domain = lp_realm(); } else { domain = c->opt_target_workgroup; } if (argc > 0) domain=argv[0]; /* first get PDC */ if (!get_pdc_ip(domain, &ss)) return -1; print_sockaddr(addr, sizeof(addr), &ss); if (asprintf(&pdc_str, "%s", addr) == -1) { return -1; } d_printf("%s\n", pdc_str); sitename = sitename_fetch(talloc_tos(), domain); if (!NT_STATUS_IS_OK(get_sorted_dc_list(domain, sitename, &ip_list, &count, sec_ads))) { SAFE_FREE(pdc_str); TALLOC_FREE(sitename); return 0; } TALLOC_FREE(sitename); for (i=0;i<count;i++) { print_sockaddr(addr, sizeof(addr), &ip_list[i].ss); if (!strequal(pdc_str, addr)) d_printf("%s\n", addr); } SAFE_FREE(pdc_str); return 0; }
static void add_interface(const struct iface_struct *ifs) { char addr[INET6_ADDRSTRLEN]; struct interface *iface; if (iface_find((const struct sockaddr *)&ifs->ip, False)) { DEBUG(3,("add_interface: not adding duplicate interface %s\n", print_sockaddr(addr, sizeof(addr), &ifs->ip) )); return; } if (!(ifs->flags & (IFF_BROADCAST|IFF_LOOPBACK))) { DEBUG(3,("not adding non-broadcast interface %s\n", ifs->name )); return; } iface = SMB_MALLOC_P(struct interface); if (!iface) { return; } ZERO_STRUCTPN(iface); iface->name = SMB_STRDUP(ifs->name); if (!iface->name) { SAFE_FREE(iface); return; } iface->flags = ifs->flags; iface->ip = ifs->ip; iface->netmask = ifs->netmask; iface->bcast = ifs->bcast; DLIST_ADD(local_interfaces, iface); DEBUG(2,("added interface %s ip=%s ", iface->name, print_sockaddr(addr, sizeof(addr), &iface->ip) )); DEBUG(2,("bcast=%s ", print_sockaddr(addr, sizeof(addr), &iface->bcast) )); DEBUG(2,("netmask=%s\n", print_sockaddr(addr, sizeof(addr), &iface->netmask) )); }
int accept(int sockfd, struct sockaddr *addr, socklen_t addrlen) { if (!orig_accept) orig_accept = (orig_accept_t)dlsym(RTLD_NEXT, "accept"); int rv = orig_accept(sockfd, addr, addrlen); print_sockaddr(sockfd, "accept", addr, rv); return rv; }
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) { if (!orig_bind) orig_bind = (orig_bind_t)dlsym(RTLD_NEXT, "bind"); int rv = orig_bind(sockfd, addr, addrlen); print_sockaddr(sockfd, "bind", addr, rv); return rv; }
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) { if (!orig_connect) orig_connect = (orig_connect_t)dlsym(RTLD_NEXT, "connect"); int rv = orig_connect(sockfd, addr, addrlen); print_sockaddr(sockfd, "connect", addr, rv); return rv; }
void winbindd_wins_byname(struct winbindd_cli_state *state) { struct sockaddr_storage *ip_list = NULL; int i, count, maxlen, size; fstring response; char addr[INET6_ADDRSTRLEN]; /* Ensure null termination */ state->request->data.winsreq[sizeof(state->request->data.winsreq)-1]='\0'; DEBUG(3, ("[%5lu]: wins_byname %s\n", (unsigned long)state->pid, state->request->data.winsreq)); *response = '\0'; maxlen = sizeof(response) - 1; ip_list = lookup_byname_backend( state->mem_ctx, state->request->data.winsreq, &count); if (ip_list != NULL){ for (i = count; i ; i--) { print_sockaddr(addr, sizeof(addr), &ip_list[i-1]); size = strlen(addr); if (size > maxlen) { TALLOC_FREE(ip_list); request_error(state); return; } if (i != 0) { /* Clear out the newline character */ /* But only if there is something in there, otherwise we clobber something in the stack */ if (strlen(response)) { response[strlen(response)-1] = ' '; } } fstrcat(response,addr); fstrcat(response,"\t"); } size = strlen(state->request->data.winsreq) + strlen(response); if (size > maxlen) { TALLOC_FREE(ip_list); request_error(state); return; } fstrcat(response,state->request->data.winsreq); fstrcat(response,"\n"); TALLOC_FREE(ip_list); } else { request_error(state); return; } fstrcpy(state->response->data.winsresp,response); request_ok(state); }
static void print_cmsg_ip_origdstaddr(struct tcb *tcp, const void *cmsg_data, const size_t data_len) { if (sizeof(struct sockaddr_in) > data_len) return; tprints(", "); print_sockaddr(tcp, cmsg_data, data_len); }
static void print_cmsg_ip_origdstaddr(struct tcb *tcp, const void *cmsg_data, const size_t data_len) { const int addr_len = data_len > sizeof(struct sockaddr_storage) ? sizeof(struct sockaddr_storage) : data_len; print_sockaddr(tcp, cmsg_data, addr_len); }
static NTSTATUS process_dc_dns(TALLOC_CTX *mem_ctx, const char *domain_name, uint32_t flags, struct ip_service_name *dclist, int num_dcs, struct netr_DsRGetDCNameInfo **info) { int i = 0; bool valid_dc = false; struct netlogon_samlogon_response *r = NULL; uint32_t nt_version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX; uint32_t ret_flags = 0; NTSTATUS status; nt_version |= map_ds_flags_to_nt_version(flags); for (i=0; i<num_dcs; i++) { char addr[INET6_ADDRSTRLEN]; print_sockaddr(addr, sizeof(addr), &dclist[i].ss); DEBUG(10,("LDAP ping to %s (%s)\n", dclist[i].hostname, addr)); if (ads_cldap_netlogon(mem_ctx, &dclist[i].ss, domain_name, nt_version, &r)) { nt_version = r->ntver; ret_flags = get_cldap_reply_server_flags(r, nt_version); if (check_cldap_reply_required_flags(ret_flags, flags)) { valid_dc = true; break; } } continue; } if (!valid_dc) { return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND; } status = make_dc_info_from_cldap_reply(mem_ctx, flags, &dclist[i].ss, &r->data.nt5_ex, info); if (NT_STATUS_IS_OK(status)) { return store_cldap_reply(mem_ctx, flags, &dclist[i].ss, nt_version, &r->data.nt5_ex); } return status; }
static int net_lookup_kdc(struct net_context *c, int argc, const char **argv) { #ifdef HAVE_KRB5 krb5_error_code rc; krb5_context ctx; struct ip_service *kdcs; const char *realm; int num_kdcs = 0; int i; NTSTATUS status; initialize_krb5_error_table(); rc = krb5_init_context(&ctx); if (rc) { DEBUG(1,("krb5_init_context failed (%s)\n", error_message(rc))); return -1; } if (argc > 0) { realm = argv[0]; } else if (lp_realm() && *lp_realm()) { realm = lp_realm(); } else { char **realms; rc = krb5_get_host_realm(ctx, NULL, &realms); if (rc) { DEBUG(1,("krb5_gethost_realm failed (%s)\n", error_message(rc))); return -1; } realm = (const char *) *realms; } status = get_kdc_list(realm, NULL, &kdcs, &num_kdcs); if (!NT_STATUS_IS_OK(status)) { DEBUG(1,("get_kdc_list failed (%s)\n", nt_errstr(status))); return -1; } for (i = 0; i < num_kdcs; i++) { char addr[INET6_ADDRSTRLEN]; print_sockaddr(addr, sizeof(addr), &kdcs[i].ss); d_printf("%s:%u\n", addr, kdcs[i].port); } return 0; #endif DEBUG(1, ("No kerberos support\n")); return -1; }
static bool rpc_dc_name(const char *domain, fstring srv_name, struct sockaddr_storage *ss_out) { struct ip_service *ip_list = NULL; struct sockaddr_storage dc_ss; int count, i; NTSTATUS result; char addr[INET6_ADDRSTRLEN]; /* get a list of all domain controllers */ if (!NT_STATUS_IS_OK(get_sorted_dc_list(domain, NULL, &ip_list, &count, False))) { DEBUG(3, ("Could not look up dc's for domain %s\n", domain)); return False; } /* Remove the entry we've already failed with (should be the PDC). */ for (i = 0; i < count; i++) { if (is_zero_addr((struct sockaddr *)&ip_list[i].ss)) continue; if (name_status_find(domain, 0x1c, 0x20, &ip_list[i].ss, srv_name)) { result = check_negative_conn_cache( domain, srv_name ); if ( NT_STATUS_IS_OK(result) ) { dc_ss = ip_list[i].ss; goto done; } } } SAFE_FREE(ip_list); /* No-one to talk to )-: */ return False; /* Boo-hoo */ done: /* We have the netbios name and IP address of a domain controller. Ideally we should sent a SAMLOGON request to determine whether the DC is alive and kicking. If we can catch a dead DC before performing a cli_connect() we can avoid a 30-second timeout. */ print_sockaddr(addr, sizeof(addr), &dc_ss); DEBUG(3, ("rpc_dc_name: Returning DC %s (%s) for domain %s\n", srv_name, addr, domain)); *ss_out = dc_ss; SAFE_FREE(ip_list); return True; }
static char *namecache_status_record_key(const char *name, int name_type1, int name_type2, const struct sockaddr_storage *keyip) { char addr[INET6_ADDRSTRLEN]; char *keystr; print_sockaddr(addr, sizeof(addr), keyip); asprintf_strupper_m(&keystr, "NBT/%s#%02X.%02X.%s", name, name_type1, name_type2, addr); return keystr; }
static void print_cmsg_ip_recverr(struct tcb *tcp, const void *cmsg_data, const size_t data_len) { const struct sock_ee *const err = cmsg_data; tprintf("{ee_errno=%u, ee_origin=%u, ee_type=%u, ee_code=%u" ", ee_info=%u, ee_data=%u, offender=", err->ee_errno, err->ee_origin, err->ee_type, err->ee_code, err->ee_info, err->ee_data); print_sockaddr(tcp, &err->offender, sizeof(err->offender)); tprints("}"); }
static NTSTATUS store_cldap_reply(TALLOC_CTX *mem_ctx, uint32_t flags, struct sockaddr_storage *ss, uint32_t nt_version, struct NETLOGON_SAM_LOGON_RESPONSE_EX *r) { DATA_BLOB blob; enum ndr_err_code ndr_err; NTSTATUS status; char addr[INET6_ADDRSTRLEN]; print_sockaddr(addr, sizeof(addr), ss); /* FIXME */ r->sockaddr_size = 0x10; /* the w32 winsock addr size */ r->sockaddr.sockaddr_family = 2; /* AF_INET */ r->sockaddr.pdc_ip = talloc_strdup(mem_ctx, addr); ndr_err = ndr_push_struct_blob(&blob, mem_ctx, r, (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX); if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { return ndr_map_error2ntstatus(ndr_err); } if (r->domain) { status = dsgetdcname_cache_store(mem_ctx, r->domain, &blob); if (!NT_STATUS_IS_OK(status)) { goto done; } if (r->client_site) { sitename_store(r->domain, r->client_site); } } if (r->dns_domain) { status = dsgetdcname_cache_store(mem_ctx, r->dns_domain, &blob); if (!NT_STATUS_IS_OK(status)) { goto done; } if (r->client_site) { sitename_store(r->dns_domain, r->client_site); } } status = NT_STATUS_OK; done: data_blob_free(&blob); return status; }
/**************************************************************************** display tree of smb workgroups, servers and shares ****************************************************************************/ static bool get_workgroups(struct user_auth_info *user_info) { struct cli_state *cli; struct sockaddr_storage server_ss; TALLOC_CTX *ctx = talloc_tos(); char *master_workgroup = NULL; /* Try to connect to a #1d name of our current workgroup. If that doesn't work broadcast for a master browser and then jump off that workgroup. */ master_workgroup = talloc_strdup(ctx, lp_workgroup()); if (!master_workgroup) { return false; } if (!use_bcast && !find_master_ip(lp_workgroup(), &server_ss)) { DEBUG(4,("Unable to find master browser for workgroup %s, " "falling back to broadcast\n", master_workgroup)); use_bcast = true; } if (!use_bcast) { char addr[INET6_ADDRSTRLEN]; print_sockaddr(addr, sizeof(addr), &server_ss); cli = get_ipc_connect(addr, &server_ss, user_info); if (cli == NULL) { return false; } } else { cli = get_ipc_connect_master_ip_bcast(talloc_tos(), user_info, &master_workgroup); if (cli == NULL) { DEBUG(4, ("Unable to find master browser by " "broadcast\n")); return false; } } if (!cli_NetServerEnum(cli, master_workgroup, SV_TYPE_DOMAIN_ENUM, add_name, &workgroups)) return False; return True; }
static int net_lookup_master(struct net_context *c, int argc, const char **argv) { struct sockaddr_storage master_ss; const char *domain = c->opt_target_workgroup; char addr[INET6_ADDRSTRLEN]; if (argc > 0) domain=argv[0]; if (!find_master_ip(domain, &master_ss)) return -1; print_sockaddr(addr, sizeof(addr), &master_ss); d_printf("%s\n", addr); return 0; }
static void print_group_req(struct tcb *tcp, long addr, int len) { struct group_req greq; if (len != sizeof(greq) || umove(tcp, addr, &greq) < 0) { printaddr(addr); return; } tprintf("{gr_interface=%u, gr_group=", greq.gr_interface); print_sockaddr(tcp, &greq.gr_group, sizeof(greq.gr_group)); tprintf("}"); }
static void print_ldap_srvlist(struct dns_rr_srv *dclist, int numdcs ) { struct sockaddr_storage ss; int i; for ( i=0; i<numdcs; i++ ) { if (resolve_name(dclist[i].hostname, &ss, 0x20, true) ) { char addr[INET6_ADDRSTRLEN]; print_sockaddr(addr, sizeof(addr), &ss); #ifdef HAVE_IPV6 if (ss.ss_family == AF_INET6) { d_printf("[%s]:%d\n", addr, dclist[i].port); } #endif if (ss.ss_family == AF_INET) { d_printf("%s:%d\n", addr, dclist[i].port); } } } }
void printsock(struct tcb *tcp, long addr, int addrlen) { sockaddr_buf_t addrbuf; if (addrlen < 2) { printaddr(addr); return; } if (addrlen > (int) sizeof(addrbuf)) addrlen = sizeof(addrbuf); memset(&addrbuf, 0, sizeof(addrbuf)); if (umoven_or_printaddr(tcp, addr, addrlen, addrbuf.pad)) return; addrbuf.pad[sizeof(addrbuf.pad) - 1] = '\0'; print_sockaddr(tcp, &addrbuf, addrlen); }
static bool do_node_status(const char *name, int type, struct sockaddr_storage *pss) { struct nmb_name nname; int count, i, j; struct node_status *addrs; struct node_status_extra extra; fstring cleanname; char addr[INET6_ADDRSTRLEN]; NTSTATUS status; print_sockaddr(addr, sizeof(addr), pss); d_printf("Looking up status of %s\n",addr); make_nmb_name(&nname, name, type); status = node_status_query(talloc_tos(), &nname, pss, &addrs, &count, &extra); if (NT_STATUS_IS_OK(status)) { for (i=0;i<count;i++) { pull_ascii_fstring(cleanname, addrs[i].name); for (j=0;cleanname[j];j++) { if (!isprint((int)cleanname[j])) { cleanname[j] = '.'; } } d_printf("\t%-15s <%02x> - %s\n", cleanname,addrs[i].type, node_status_flags(addrs[i].flags)); } d_printf("\n\tMAC Address = %02X-%02X-%02X-%02X-%02X-%02X\n", extra.mac_addr[0], extra.mac_addr[1], extra.mac_addr[2], extra.mac_addr[3], extra.mac_addr[4], extra.mac_addr[5]); d_printf("\n"); TALLOC_FREE(addrs); return true; } else { d_printf("No reply from %s\n\n",addr); return false; } }
/* Create a new socket_address from sockaddr_storage */ _PUBLIC_ struct socket_address *socket_address_from_sockaddr_storage(TALLOC_CTX *mem_ctx, const struct sockaddr_storage *sockaddr, uint16_t port) { struct socket_address *addr = talloc_zero(mem_ctx, struct socket_address); char addr_str[INET6_ADDRSTRLEN+1]; const char *str; if (!addr) { return NULL; } addr->port = port; switch (sockaddr->ss_family) { case AF_INET: addr->family = "ipv4"; break; #ifdef HAVE_IPV6 case AF_INET6: addr->family = "ipv6"; break; #endif default: talloc_free(addr); return NULL; } str = print_sockaddr(addr_str, sizeof(addr_str), sockaddr); if (str == NULL) { talloc_free(addr); return NULL; } addr->addr = talloc_strdup(addr, str); if (addr->addr == NULL) { talloc_free(addr); return NULL; } return addr; }
static void do_node_status(int fd, const char *name, int type, struct sockaddr_storage *pss) { struct nmb_name nname; int count, i, j; NODE_STATUS_STRUCT *status; struct node_status_extra extra; fstring cleanname; char addr[INET6_ADDRSTRLEN]; print_sockaddr(addr, sizeof(addr), pss); d_printf("Looking up status of %s\n",addr); make_nmb_name(&nname, name, type); status = node_status_query(fd, &nname, pss, &count, &extra); if (status) { for (i=0;i<count;i++) { pull_ascii_fstring(cleanname, status[i].name); for (j=0;cleanname[j];j++) { if (!isprint((int)cleanname[j])) { cleanname[j] = '.'; } } d_printf("\t%-15s <%02x> - %s\n", cleanname,status[i].type, node_status_flags(status[i].flags)); } d_printf("\n\tMAC Address = %02X-%02X-%02X-%02X-%02X-%02X\n", extra.mac_addr[0], extra.mac_addr[1], extra.mac_addr[2], extra.mac_addr[3], extra.mac_addr[4], extra.mac_addr[5]); d_printf("\n"); SAFE_FREE(status); } else { d_printf("No reply from %s\n\n",addr); } }
static bool get_servers(char *workgroup, struct user_auth_info *user_info) { struct cli_state *cli; struct sockaddr_storage server_ss; char addr[INET6_ADDRSTRLEN]; /* Open an IPC$ connection to the master browser for the workgroup */ if (!find_master_ip(workgroup, &server_ss)) { DEBUG(4, ("Cannot find master browser for workgroup %s\n", workgroup)); return False; } print_sockaddr(addr, sizeof(addr), &server_ss); if (!(cli = get_ipc_connect(addr, &server_ss, user_info))) return False; if (!cli_NetServerEnum(cli, workgroup, SV_TYPE_ALL, add_name, &servers)) return False; return True; }