/* do a cldap netlogon query */ static int send_cldap_netlogon(int sock, const char *domain, const char *hostname, unsigned ntversion) { ASN1_DATA data; char ntver[4]; #ifdef CLDAP_USER_QUERY char aac[4]; SIVAL(aac, 0, 0x00000180); #endif SIVAL(ntver, 0, ntversion); memset(&data, 0, sizeof(data)); asn1_push_tag(&data,ASN1_SEQUENCE(0)); asn1_write_Integer(&data, 4); asn1_push_tag(&data, ASN1_APPLICATION(3)); asn1_write_OctetString(&data, NULL, 0); asn1_write_enumerated(&data, 0); asn1_write_enumerated(&data, 0); asn1_write_Integer(&data, 0); asn1_write_Integer(&data, 0); asn1_write_BOOLEAN2(&data, False); asn1_push_tag(&data, ASN1_CONTEXT(0)); asn1_push_tag(&data, ASN1_CONTEXT(3)); asn1_write_OctetString(&data, "DnsDomain", 9); asn1_write_OctetString(&data, domain, strlen(domain)); asn1_pop_tag(&data); asn1_push_tag(&data, ASN1_CONTEXT(3)); asn1_write_OctetString(&data, "Host", 4); asn1_write_OctetString(&data, hostname, strlen(hostname)); asn1_pop_tag(&data); #ifdef CLDAP_USER_QUERY asn1_push_tag(&data, ASN1_CONTEXT(3)); asn1_write_OctetString(&data, "User", 4); asn1_write_OctetString(&data, "SAMBA$", 6); asn1_pop_tag(&data); asn1_push_tag(&data, ASN1_CONTEXT(3)); asn1_write_OctetString(&data, "AAC", 4); asn1_write_OctetString(&data, aac, 4); asn1_pop_tag(&data); #endif asn1_push_tag(&data, ASN1_CONTEXT(3)); asn1_write_OctetString(&data, "NtVer", 5); asn1_write_OctetString(&data, ntver, 4); asn1_pop_tag(&data); asn1_pop_tag(&data); asn1_push_tag(&data,ASN1_SEQUENCE(0)); asn1_write_OctetString(&data, "NetLogon", 8); asn1_pop_tag(&data); asn1_pop_tag(&data); asn1_pop_tag(&data); if (data.has_error) { d_printf("Failed to build cldap netlogon at offset %d\n", (int)data.ofs); asn1_free(&data); return -1; } if (write(sock, data.data, data.length) != (ssize_t)data.length) { d_printf("failed to send cldap query (%s)\n", strerror(errno)); } asn1_free(&data); return 0; }
ssize_t SMBC_write_ctx(SMBCCTX *context, SMBCFILE *file, const void *buf, size_t count) { off_t offset; char *server = NULL, *share = NULL, *user = NULL, *password = NULL; char *path = NULL; char *targetpath = NULL; struct cli_state *targetcli = NULL; TALLOC_CTX *frame = talloc_stackframe(); NTSTATUS status; /* First check all pointers before dereferencing them */ if (!context || !context->internal->initialized) { errno = EINVAL; TALLOC_FREE(frame); return -1; } if (!file || !SMBC_dlist_contains(context->internal->files, file)) { errno = EBADF; TALLOC_FREE(frame); return -1; } /* Check that the buffer exists ... */ if (buf == NULL) { errno = EINVAL; TALLOC_FREE(frame); return -1; } offset = file->offset; /* See "offset" comment in SMBC_read_ctx() */ /*d_printf(">>>write: parsing %s\n", file->fname);*/ if (SMBC_parse_path(frame, context, file->fname, NULL, &server, &share, &path, &user, &password, NULL)) { errno = EINVAL; TALLOC_FREE(frame); return -1; } /*d_printf(">>>write: resolving %s\n", path);*/ status = cli_resolve_path(frame, "", context->internal->auth_info, file->srv->cli, path, &targetcli, &targetpath); if (!NT_STATUS_IS_OK(status)) { d_printf("Could not resolve %s\n", path); errno = ENOENT; TALLOC_FREE(frame); return -1; } /*d_printf(">>>write: resolved path as %s\n", targetpath);*/ status = cli_writeall(targetcli, file->cli_fd, 0, (const uint8_t *)buf, offset, count, NULL); if (!NT_STATUS_IS_OK(status)) { errno = map_errno_from_nt_status(status); TALLOC_FREE(frame); return -1; } file->offset += count; TALLOC_FREE(frame); return count; /* Success, 0 bytes of data ... */ }
int SMBC_close_ctx(SMBCCTX *context, SMBCFILE *file) { SMBCSRV *srv; char *server = NULL, *share = NULL, *user = NULL, *password = NULL; char *path = NULL; char *targetpath = NULL; struct cli_state *targetcli = NULL; TALLOC_CTX *frame = talloc_stackframe(); NTSTATUS status; if (!context || !context->internal->initialized) { errno = EINVAL; TALLOC_FREE(frame); return -1; } if (!file || !SMBC_dlist_contains(context->internal->files, file)) { errno = EBADF; TALLOC_FREE(frame); return -1; } /* IS a dir ... */ if (!file->file) { TALLOC_FREE(frame); return smbc_getFunctionClosedir(context)(context, file); } /*d_printf(">>>close: parsing %s\n", file->fname);*/ if (SMBC_parse_path(frame, context, file->fname, NULL, &server, &share, &path, &user, &password, NULL)) { errno = EINVAL; TALLOC_FREE(frame); return -1; } /*d_printf(">>>close: resolving %s\n", path);*/ status = cli_resolve_path(frame, "", context->internal->auth_info, file->srv->cli, path, &targetcli, &targetpath); if (!NT_STATUS_IS_OK(status)) { d_printf("Could not resolve %s\n", path); errno = ENOENT; TALLOC_FREE(frame); return -1; } /*d_printf(">>>close: resolved path as %s\n", targetpath);*/ if (!NT_STATUS_IS_OK(cli_close(targetcli, file->cli_fd))) { DEBUG(3, ("cli_close failed on %s. purging server.\n", file->fname)); /* Deallocate slot and remove the server * from the server cache if unused */ errno = SMBC_errno(context, targetcli); srv = file->srv; DLIST_REMOVE(context->internal->files, file); SAFE_FREE(file->fname); SAFE_FREE(file); smbc_getFunctionRemoveUnusedServer(context)(context, srv); TALLOC_FREE(frame); return -1; } DLIST_REMOVE(context->internal->files, file); SAFE_FREE(file->fname); SAFE_FREE(file); TALLOC_FREE(frame); return 0; }
/* Execute a command, with optional params send (in[in_len]) and ** results received (out[out_len]) */ static int bl_execute(BusLogic *bl, uchar command, void *in, int in_len, void *out, int out_len) { uchar status; uchar *_in, *_out; #ifdef TIMEOUT int timeout; #endif _in = (uchar *) in; _out = (uchar *) out; if(!(inb(BL_STATUS_REG) & BL_STATUS_HARDY)) { d_printf("buslogic: command 0x%02x %d/%d, not ready\n", command, in_len, out_len); return 1; } outb(BL_COMMAND_REG, command); #ifdef TIMEOUT timeout = 100; #endif while(in_len) { status = inb(BL_STATUS_REG); if(status & BL_STATUS_CMDINV) { d_printf("buslogic: command 0x%02x %d/%d invalid\n", command, in_len, out_len); return 1; } if(status & BL_STATUS_CPRBSY) { #ifdef TIMEOUT timeout--; if(!timeout) { d_printf("buslogic: command 0x%02 timed out (a)\n",command); return 1; } spin(100); #endif continue; } outb(BL_COMMAND_REG, *_in); _in++; in_len--; } #ifdef TIMEOUT timeout = 100; #endif while(out_len) { status = inb(BL_STATUS_REG); if(status & BL_STATUS_CMDINV) { d_printf("buslogic: command 0x%02x %d/%d invalid\n", command, in_len, out_len); return 1; } if(status & BL_STATUS_DIRRDY) { *_out = inb(BL_DATA_REG); _out++; out_len--; } else { #ifdef TIMEOUT timeout--; if(!timeout) { d_printf("buslogic: command 0x%02 timed out (b)\n",command); return 1; } spin(100); #endif } } #ifdef TIMEOUT timeout = 100; #endif while(!(inb(BL_STATUS_REG) & BL_STATUS_HARDY)) { #ifdef TIMEOUT timeout--; if(!timeout) { d_printf("buslogic: command 0x%02 timed out (c)\n",command); return 1; } spin(100); #endif } return 0; }
/* sim_invalid() ** ** Generic invalid XPT command response */ static long sim_invalid(BusLogic *bl, CCB_HEADER *ccbh) { ccbh->cam_status = CAM_REQ_INVALID; d_printf("sim_invalid\n"); return B_ERROR; }
static void group_member_fn(const char *user_name, void *state) { d_printf("%-21.21s\n", user_name); }
static void group_fn(const char *group_name, void *state) { d_printf("%-21.21s\n", group_name); }
int jpeg_display_rgb(int argc, char *argv[]) { u_int8_t *rgb_buf;/* RGB data */ u_int8_t *jpeg_buf; /* JPEG data */ buf_t jpeg_src_buf; size_t read_size; /* read size from file */ int row_stride; int w, h, d;/* display size and depth(byte) */ boolean draw_screen; /* draw screen surface or another * surface */ int screen_status; /* 0=general 1=blue 2=red */ /* for jpeg library */ struct jpeg_decompress_struct cinfo; struct jpeg_error_mgr jerr; /* for SDL */ SDL_Surface *screen; SDL_Surface *sdl_image = NULL; // SDL_Rect dstrect; /* for visualize packet loss */ SDL_Surface *sdl_img_blue = NULL; SDL_Surface *sdl_img_red = NULL; u_int8_t pixel_blue[]={0,0,0xff}; u_int8_t pixel_red[]={0xff,0,0}; u_int32_t tick_start, tick_now; int buf_status; /* -1=full */ /* for realtime play */ struct timeval tv_start,tv_now; int64_t ts_display,ts_diff; u_int32_t ts_nowblk,ts_lastblk=0; /* for debug */ struct timeval tv_tmp1, tv_tmp2; /* SDL init */ if (SDL_Init(SDL_INIT_VIDEO) < 0) { ComplainAndExit(); } atexit(SDL_Quit); /* jpeg library init / get image size and depth */ cinfo.err = jpeg_std_error(&jerr); cinfo.err->error_exit = my_jpeg_abort_decompress; jpeg_create_decompress(&cinfo); #ifdef USE_JPEG_MEM_SRC jpeg_buf = jpeg_mem_src_init(&cinfo, JPEG_BUF_MAX); /* init */ #else jpeg_buf = (u_int8_t *) malloc(JPEG_BUF_MAX); #endif decoder_buf_read(); read_size = decoder_buf_get(jpeg_buf, JPEG_BUF_MAX,&ts_nowblk); #ifdef USE_JPEG_MEM_SRC jpeg_mem_src(&cinfo, jpeg_buf, read_size); /* read from memory */ #else jpeg_src_buf.buf = jpeg_buf; jpeg_buf_src(&cinfo, jpeg_buf, read_size); /* read from memory */ #endif jpeg_read_header(&cinfo, TRUE); w = cinfo.image_width; h = cinfo.image_height; d = cinfo.num_components; jpeg_abort_decompress(&cinfo); d_printf("\nJPEG info: image=(%d,%d), output=(%d,%d), Bpp=%d\n", cinfo.image_width, cinfo.image_height, w, h, d); /* SDL setup / cleanup screen-surface */ screen = SDL_SetVideoMode(w, h, 0, SDL_HWSURFACE); if (screen == NULL) { ComplainAndExit(); } if (OPT.loss_visual){ sdl_img_blue = SDL_CreateRGBSurface( SDL_HWSURFACE, w, h, 24 ,OPT.sdl_mask_R, OPT.sdl_mask_G ,OPT.sdl_mask_B, OPT.sdl_mask_A); sdl_img_red = SDL_CreateRGBSurface( SDL_HWSURFACE, w, h, 24 ,OPT.sdl_mask_R, OPT.sdl_mask_G ,OPT.sdl_mask_B, OPT.sdl_mask_A); jpeg_fillimg1color(sdl_img_red,pixel_red,3); jpeg_fillimg1color(sdl_img_blue,pixel_blue,3); } if (screen->format->BytesPerPixel == RGB_PIXELSIZE && screen->format->Rmask == OPT.sdl_mask_R && screen->format->Gmask == OPT.sdl_mask_G && screen->format->Bmask == OPT.sdl_mask_B) { draw_screen = TRUE; } else { draw_screen = FALSE; } d1_printf("\nSDL screen info: bpp=%d, Bpp=%d, " "R/G/B-mask=%06x/%06x/%06x, Direct=%s", screen->format->BitsPerPixel, screen->format->BytesPerPixel, screen->format->Rmask, screen->format->Gmask, screen->format->Bmask, draw_screen ? "ON" : "OFF"); if (draw_screen==TRUE) { /* RGB_PIXELSIZE is defined in jmorecfg.h */ row_stride = screen->pitch; rgb_buf = (u_int8_t *) screen->pixels; } else { sdl_image = SDL_CreateRGBSurface( SDL_HWSURFACE, w, h, 24, /* depth (bit per pixel) */ OPT.sdl_mask_R, OPT.sdl_mask_G, OPT.sdl_mask_B, OPT.sdl_mask_A); row_stride = sdl_image->pitch; d1_printf("\nSDL surface info: bpp=%d, Bpp=%d, " "R/G/B-mask=%06x/%06x/%06x\n", sdl_image->format->BitsPerPixel, sdl_image->format->BytesPerPixel, sdl_image->format->Rmask, sdl_image->format->Gmask, sdl_image->format->Bmask ); rgb_buf = (u_int8_t *) sdl_image->pixels; } STAT.skip_count = 0; STAT.wait_count = 0; tick_start = SDL_GetTicks(); /* get start time */ gettimeofday(&STAT.start, NULL); gettimeofday(&tv_start, NULL); ts_display=0; STAT.f_sigint = 0; signal(SIGINT, sigint_trap); jpeg_fillimg1color(screen,pixel_blue,3); screen_status=1; for (STAT.frame_count = 1;; STAT.frame_count++) { if (STAT.f_sigint) sigint_quit(); jpeg_has_error = 0; /* reset flag */ buf_status=decoder_buf_read(); #if 0 read_size = decoder_buf_get(jpeg_buf, JPEG_BUF_MAX); #ifdef REALTIME_PLAY tick_now = SDL_GetTicks(); if (tick_now - tick_start > STAT.frame_count * OPT.mspf) { /* skip frame because it's too late */ STAT.skip_count++; continue; } #endif #else read_size = decoder_buf_get(jpeg_buf, JPEG_BUF_MAX,&ts_nowblk); #ifdef REALTIME_PLAY if(buf_status==-1){ /* need more cpu power */ if(OPT.loss_visual){ jpeg_blitimg2screen(sdl_img_red,screen); screen_status=2; } d1_printf("INFO:buffer skip\n"); STAT.skip_count+=decoder_buf_get_datanum()/2; STAT.frame_count+=decoder_buf_get_datanum()/2; decoder_buf_rm(decoder_buf_get_datanum()/2); ts_display=0; gettimeofday(&tv_start, NULL); continue; } #endif #endif if (read_size == 0) { /* buffer empty */ d1_printf("INFO:buffer empty\n"); STAT.frame_count--; /* no skip, no display */ if(OPT.loss_visual && screen_status!=1){ jpeg_blitimg2screen(sdl_img_blue,screen); screen_status=1; } decoder_buf_prebuf(); ts_display=0; gettimeofday(&tv_start, NULL); continue; } else if (read_size == -2) { break; /* end of all files */ } #ifdef USE_JPEG_MEM_SRC jpeg_mem_src(&cinfo, jpeg_buf, read_size); #else jpeg_src_buf.buf = jpeg_buf; jpeg_buf_src(&cinfo, jpeg_buf, read_size); #endif jpeg_read_header(&cinfo, TRUE); cinfo.output_width = w; cinfo.output_height = h; cinfo.out_color_space = JCS_RGB; /* default */ cinfo.output_components = d; /* more fast decompression */ cinfo.dct_method = JDCT_FASTEST; //cinfo.dct_method = JDCT_FLOAT; cinfo.do_fancy_upsampling = FALSE; jpeg_start_decompress(&cinfo); /* screen surface lock */ if (SDL_MUSTLOCK(screen)) { if (SDL_LockSurface(screen) < 0) { ComplainAndExit(); } } /* JPEG decode start */ gettimeofday(&tv_tmp1, NULL); while (cinfo.output_scanline < cinfo.output_height && !jpeg_has_error) { JSAMPLE *rgb_scanline; rgb_scanline = &(rgb_buf[cinfo.output_scanline * row_stride]); jpeg_read_scanlines(&cinfo, &rgb_scanline, 1); } /* screen surface unlock */ if (SDL_MUSTLOCK(screen)) { SDL_UnlockSurface(screen); } jpeg_finish_decompress(&cinfo); /* JPEG decode finish */ gettimeofday(&tv_tmp2, NULL); STAT.decode_usec += timeval_diff_usec(&tv_tmp2, &tv_tmp1); #ifdef REALTIME_PLAY wait4rtdisplay(&tv_start,ts_display); if(ts_display==0){ ts_diff=OPT.freq; }else{ ts_diff=(u_int32_t)(ts_nowblk-ts_lastblk); } ts_lastblk=ts_nowblk; if(ts_diff<OPT.freq){ e_printf("INFO:reset TS interval\n"); } if(ts_diff>OPT.freq){ d2_printf("blue back start for %u TS\n",(u_int32_t)ts_diff-OPT.freq); ts_display+=(ts_diff-OPT.freq); if(OPT.loss_visual && screen_status!=1){ jpeg_blitimg2screen(sdl_img_blue,screen); screen_status=1; } wait4rtdisplay(&tv_start,ts_display); d2_printf("blue back end.\n"); }else{ d3_printf("no blue back .\n"); } ts_display+= OPT.freq; #endif if (draw_screen==TRUE) { SDL_UpdateRect(screen, 0, 0, 0, 0); screen_status=0; } else { jpeg_blitimg2screen(sdl_image,screen); screen_status=0; #if 0 dstrect.x = 0; dstrect.y = 0; dstrect.w = sdl_image->w; dstrect.h = sdl_image->h; if (SDL_BlitSurface(sdl_image, NULL, screen, &dstrect) < 0) { SDL_FreeSurface(sdl_image); ComplainAndExit(); } #if 0 if (SDL_MUSTLOCK(screen)) { SDL_UnlockSurface(screen); } #endif SDL_UpdateRects(screen, 1, &dstrect); #endif } } /* loop for all jpeg file */ STAT.frame_count--; /* because count from 1 */ tick_now = SDL_GetTicks(); if (!draw_screen) { SDL_FreeSurface(sdl_image); } jpeg_destroy_decompress(&cinfo); statistics_print(&STAT); return 0; }
/* * Act on a TLV System State reported by the device * * @i2400m: device descriptor * @ss: validated System State TLV */ static void i2400m_report_tlv_system_state(struct i2400m *i2400m, const struct i2400m_tlv_system_state *ss) { struct device *dev = i2400m_dev(i2400m); struct wimax_dev *wimax_dev = &i2400m->wimax_dev; enum i2400m_system_state i2400m_state = le32_to_cpu(ss->state); d_fnstart(3, dev, "(i2400m %p ss %p [%u])\n", i2400m, ss, i2400m_state); if (unlikely(i2400m->ready == 0)) /* act if up */ goto out; if (i2400m->state != i2400m_state) { i2400m->state = i2400m_state; wake_up_all(&i2400m->state_wq); } switch (i2400m_state) { case I2400M_SS_UNINITIALIZED: case I2400M_SS_INIT: case I2400M_SS_CONFIG: case I2400M_SS_PRODUCTION: wimax_state_change(wimax_dev, WIMAX_ST_UNINITIALIZED); break; case I2400M_SS_RF_OFF: case I2400M_SS_RF_SHUTDOWN: wimax_state_change(wimax_dev, WIMAX_ST_RADIO_OFF); break; case I2400M_SS_READY: case I2400M_SS_STANDBY: case I2400M_SS_SLEEPACTIVE: wimax_state_change(wimax_dev, WIMAX_ST_READY); break; case I2400M_SS_CONNECTING: case I2400M_SS_WIMAX_CONNECTED: wimax_state_change(wimax_dev, WIMAX_ST_READY); break; case I2400M_SS_SCAN: case I2400M_SS_OUT_OF_ZONE: wimax_state_change(wimax_dev, WIMAX_ST_SCANNING); break; case I2400M_SS_IDLE: d_printf(1, dev, "entering BS-negotiated idle mode\n"); case I2400M_SS_DISCONNECTING: case I2400M_SS_DATA_PATH_CONNECTED: wimax_state_change(wimax_dev, WIMAX_ST_CONNECTED); break; default: /* Huh? just in case, shut it down */ dev_err(dev, "HW BUG? unknown state %u: shutting down\n", i2400m_state); i2400m->bus_reset(i2400m, I2400M_RT_WARM); break; }; out: d_fnend(3, dev, "(i2400m %p ss %p [%u]) = void\n", i2400m, ss, i2400m_state); }
static NTSTATUS do_connect(TALLOC_CTX *ctx, const char *server, const char *share, const struct user_auth_info *auth_info, bool show_sessetup, bool force_encrypt, int max_protocol, int port, int name_type, struct cli_state **pcli) { struct cli_state *c = NULL; char *servicename; char *sharename; char *newserver, *newshare; const char *username; const char *password; NTSTATUS status; int flags = 0; /* make a copy so we don't modify the global string 'service' */ servicename = talloc_strdup(ctx,share); if (!servicename) { return NT_STATUS_NO_MEMORY; } sharename = servicename; if (*sharename == '\\') { sharename += 2; if (server == NULL) { server = sharename; } sharename = strchr_m(sharename,'\\'); if (!sharename) { return NT_STATUS_NO_MEMORY; } *sharename = 0; sharename++; } if (server == NULL) { return NT_STATUS_INVALID_PARAMETER; } if (get_cmdline_auth_info_use_kerberos(auth_info)) { flags |= CLI_FULL_CONNECTION_USE_KERBEROS; } if (get_cmdline_auth_info_fallback_after_kerberos(auth_info)) { flags |= CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS; } if (get_cmdline_auth_info_use_ccache(auth_info)) { flags |= CLI_FULL_CONNECTION_USE_CCACHE; } status = cli_connect_nb( server, NULL, port, name_type, NULL, get_cmdline_auth_info_signing_state(auth_info), flags, &c); if (!NT_STATUS_IS_OK(status)) { d_printf("Connection to %s failed (Error %s)\n", server, nt_errstr(status)); return status; } if (max_protocol == 0) { max_protocol = PROTOCOL_NT1; } DEBUG(4,(" session request ok\n")); status = cli_negprot(c, max_protocol); if (!NT_STATUS_IS_OK(status)) { d_printf("protocol negotiation failed: %s\n", nt_errstr(status)); cli_shutdown(c); return status; } username = get_cmdline_auth_info_username(auth_info); password = get_cmdline_auth_info_password(auth_info); status = cli_session_setup(c, username, password, strlen(password), password, strlen(password), lp_workgroup()); if (!NT_STATUS_IS_OK(status)) { /* If a password was not supplied then * try again with a null username. */ if (password[0] || !username[0] || get_cmdline_auth_info_use_kerberos(auth_info) || !NT_STATUS_IS_OK(status = cli_session_setup(c, "", "", 0, "", 0, lp_workgroup()))) { d_printf("session setup failed: %s\n", nt_errstr(status)); if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) d_printf("did you forget to run kinit?\n"); cli_shutdown(c); return status; } d_printf("Anonymous login successful\n"); status = cli_init_creds(c, "", lp_workgroup(), ""); } else { status = cli_init_creds(c, username, lp_workgroup(), password); } if (!NT_STATUS_IS_OK(status)) { DEBUG(10,("cli_init_creds() failed: %s\n", nt_errstr(status))); cli_shutdown(c); return status; } if ( show_sessetup ) { if (*c->server_domain) { DEBUG(0,("Domain=[%s] OS=[%s] Server=[%s]\n", c->server_domain,c->server_os,c->server_type)); } else if (*c->server_os || *c->server_type) { DEBUG(0,("OS=[%s] Server=[%s]\n", c->server_os,c->server_type)); } } DEBUG(4,(" session setup ok\n")); /* here's the fun part....to support 'msdfs proxy' shares (on Samba or windows) we have to issues a TRANS_GET_DFS_REFERRAL here before trying to connect to the original share. cli_check_msdfs_proxy() will fail if it is a normal share. */ if ((cli_state_capabilities(c) & CAP_DFS) && cli_check_msdfs_proxy(ctx, c, sharename, &newserver, &newshare, force_encrypt, username, password, lp_workgroup())) { cli_shutdown(c); return do_connect(ctx, newserver, newshare, auth_info, false, force_encrypt, max_protocol, port, name_type, pcli); } /* must be a normal share */ status = cli_tree_connect(c, sharename, "?????", password, strlen(password)+1); if (!NT_STATUS_IS_OK(status)) { d_printf("tree connect failed: %s\n", nt_errstr(status)); cli_shutdown(c); return status; } if (force_encrypt) { status = cli_cm_force_encryption(c, username, password, lp_workgroup(), sharename); if (!NT_STATUS_IS_OK(status)) { cli_shutdown(c); return status; } } DEBUG(4,(" tconx ok\n")); *pcli = c; return NT_STATUS_OK; }
int jpeg_display_yuv(int argc, char *argv[]) { u_int8_t *y_buf = NULL, *u_buf = NULL, *v_buf = NULL; u_int8_t *yuv_buf_tmp; u_int8_t *jpeg_buf; buf_t jpeg_src_buf; size_t read_size; /* read size from file */ int i, x, y, offU, offV; int row_stride; int w, h, d;/* display size and depth(byte) */ boolean draw_screen; /* draw screen surface or another * surface */ /* for jpeg library */ struct jpeg_decompress_struct cinfo; struct jpeg_error_mgr jerr; /* for SDL */ SDL_Surface *screen; SDL_Overlay *sdl_overlay = NULL; SDL_Rect dstrect; u_int32_t tick_start, tick_now; /* for realtime play */ struct timeval tv_start,tv_now; int64_t ts_display,ts_diff; u_int32_t ts_nowblk,ts_lastblk; /* for debug */ struct timeval tv_tmp1, tv_tmp2; /* SDL init */ if (SDL_Init(SDL_INIT_VIDEO) < 0) { ComplainAndExit(); } SDL_WM_SetCaption(OPT.title, OPT.title); atexit(SDL_Quit); /* jpeg library init / get image size and depth */ cinfo.err = jpeg_std_error(&jerr); cinfo.err->error_exit = my_jpeg_abort_decompress; jpeg_create_decompress(&cinfo); #ifdef USE_JPEG_MEM_SRC jpeg_buf = jpeg_mem_src_init(&cinfo, JPEG_BUF_MAX); /* init */ #else /* Mr.Okamura's */ jpeg_buf = (u_int8_t *) malloc(JPEG_BUF_MAX); #endif decoder_buf_read(); /* pipe -> buffer */ read_size = decoder_buf_get(jpeg_buf, JPEG_BUF_MAX,&ts_nowblk); /* buffer -> mem */ #ifdef USE_JPEG_MEM_SRC /* emon's original */ jpeg_mem_src(&cinfo, jpeg_buf, read_size); #else /* Mr.Okamura's */ jpeg_src_buf.buf = jpeg_buf; jpeg_buf_src(&cinfo, jpeg_buf, read_size); #endif jpeg_read_header(&cinfo, TRUE); w = cinfo.image_width; h = cinfo.image_height; d = cinfo.num_components; jpeg_abort_decompress(&cinfo); offU = (w * h) * 4 / 4; offV = (w * h) * 5 / 4; d_printf("\nJPEG info: image=(%d,%d), output=(%d,%d), Bpp=%d\n", cinfo.image_width, cinfo.image_height, w, h, d); /* SDL setup */ draw_screen = FALSE; /* can I draw image VRAM directly ? */ if ((screen = SDL_SetVideoMode(w, h, 0, SDL_ASYNCBLIT)) == NULL) { ComplainAndExit(); } d1_printf("\nSDL screen info: bpp=%d, Bpp=%d, " "R/G/B-mask=%06x/%06x/%06x\n", screen->format->BitsPerPixel, screen->format->BytesPerPixel, screen->format->Rmask, screen->format->Gmask, screen->format->Bmask ); if ((sdl_overlay = my_SDL_CreateYUVOverlay(w, h, screen)) == NULL) { ComplainAndExit(); } d1_printf("\nSDL surface info: format=0x%08x, planes=%d, " "hw_overlay_flag=%d\n", sdl_overlay->format, sdl_overlay->planes, sdl_overlay->hw_overlay ); row_stride = JPEG_YCbCr_PITCH * w; yuv_buf_tmp = malloc(JPEG_YCbCr_PITCH * w * h); STAT.skip_count = 0; STAT.wait_count = 0; tick_start = SDL_GetTicks(); /* get start time */ gettimeofday(&STAT.start, NULL); STAT.f_sigint = 0; signal(SIGINT, sigint_trap); for (STAT.frame_count = 1;; STAT.frame_count++) { int sleep_usec = 0; if (STAT.f_sigint) sigint_quit(); jpeg_has_error = 0; /* reset flag */ decoder_buf_read(); read_size = decoder_buf_get(jpeg_buf, JPEG_BUF_MAX,&ts_nowblk); #ifdef REALTIME_PLAY tick_now = SDL_GetTicks(); if (tick_now - tick_start > STAT.frame_count * OPT.mspf) { /* skip frame because it's too late */ STAT.skip_count++; d2_printf("s"); continue; } #endif if (read_size == 0) { /* buffer empty */ usleep(OPT.mspf * (1000 * (9 / 10))); STAT.frame_count--; /* no skip, no display */ continue; } else if (read_size == -1) { break; /* end of all files */ } #ifdef REALTIME_PLAY sleep_usec = ((STAT.frame_count - 1) * OPT.mspf - (tick_now - tick_start)) * 1000; if (sleep_usec > 0) { usleep(sleep_usec); STAT.wait_count++; //decoder_buf_read(); /* check new data */ } #endif #ifdef USE_JPEG_MEM_SRC jpeg_mem_src(&cinfo, jpeg_buf, read_size); #else jpeg_src_buf.buf = jpeg_buf; jpeg_buf_src(&cinfo, jpeg_buf, read_size); #endif jpeg_read_header(&cinfo, TRUE); cinfo.output_width = w; cinfo.output_height = h; cinfo.out_color_space = JCS_YCbCr; /* more fast decompression */ cinfo.dct_method = JDCT_FASTEST; //cinfo.dct_method = JDCT_FLOAT; cinfo.do_fancy_upsampling = FALSE; if (!jpeg_has_error) { jpeg_start_decompress(&cinfo); } /* JPEG decode start */ gettimeofday(&tv_tmp1, NULL); while (cinfo.output_scanline < cinfo.output_height && !jpeg_has_error) { JSAMPLE *yuv_scanline; yuv_scanline = &(yuv_buf_tmp[cinfo.output_scanline * row_stride]); jpeg_read_scanlines(&cinfo, &yuv_scanline, 1); } jpeg_finish_decompress(&cinfo); /* JPEG decode finish */ gettimeofday(&tv_tmp2, NULL); STAT.decode_usec += timeval_diff_usec(&tv_tmp2, &tv_tmp1); decoder_buf_read(); /* check new data */ switch (sdl_overlay->format) { case SDL_YV12_OVERLAY: #ifdef SDL_1_1_5 /* for < SDL 1.1.5 */ y_buf = (u_int8_t *) sdl_overlay->pixels; u_buf = &(y_buf[offU]); v_buf = &(y_buf[offV]); #else y_buf = sdl_overlay->pixels[0]; u_buf = sdl_overlay->pixels[1]; v_buf = sdl_overlay->pixels[2]; #endif for (i = 0; i < w * h; i++) { y_buf[i] = yuv_buf_tmp[i * JPEG_YCbCr_PITCH]; } for (i = 0, y = 0; y < h; y += 2) { for (x = 0; x < w; x += 2, i++) { const int p = (y * w + x) * JPEG_YCbCr_PITCH; u_buf[i] = yuv_buf_tmp[p + 2]; v_buf[i] = yuv_buf_tmp[p + 1]; } } break; case SDL_IYUV_OVERLAY: #ifdef SDL_1_1_5 /* for < SDL 1.1.5 */ y_buf = (u_int8_t *) sdl_overlay->pixels; v_buf = &(y_buf[offU]); u_buf = &(y_buf[offV]); #else y_buf = sdl_overlay->pixels[0]; v_buf = sdl_overlay->pixels[1]; u_buf = sdl_overlay->pixels[2]; #endif for (i = 0; i < w * h; i++) { y_buf[i] = yuv_buf_tmp[i * JPEG_YCbCr_PITCH]; } for (i = 0, y = 0; y < h; y += 2) { for (x = 0; x < w; x += 2, i++) { const int p = (y * w + x) * JPEG_YCbCr_PITCH; u_buf[i] = yuv_buf_tmp[p + 2]; v_buf[i] = yuv_buf_tmp[p + 1]; } } break; default: d_printf("\nI'm sorry. not support YUV format: %0x08x\n", sdl_overlay->format); exit(1); break; } if (OPT.f_disp) { /* display flag check */ dstrect.x = 0; dstrect.y = 0; dstrect.w = sdl_overlay->w; dstrect.h = sdl_overlay->h; if (SDL_LockYUVOverlay(sdl_overlay) < 0) { ComplainAndExit(); } if (SDL_DisplayYUVOverlay(sdl_overlay, &dstrect) < 0) { SDL_FreeYUVOverlay(sdl_overlay); ComplainAndExit(); } SDL_UnlockYUVOverlay(sdl_overlay); } } /* loop for all jpeg file */ STAT.frame_count--; /* because count up from 1 */ tick_now = SDL_GetTicks(); if (!draw_screen) { SDL_FreeYUVOverlay(sdl_overlay); } jpeg_destroy_decompress(&cinfo); statistics_print(&STAT); return 0; }
NTSTATUS cli_resolve_path(TALLOC_CTX *ctx, const char *mountpt, const struct user_auth_info *dfs_auth_info, struct cli_state *rootcli, const char *path, struct cli_state **targetcli, char **pp_targetpath) { struct client_dfs_referral *refs = NULL; size_t num_refs = 0; size_t consumed = 0; struct cli_state *cli_ipc = NULL; char *dfs_path = NULL; char *cleanpath = NULL; char *extrapath = NULL; int pathlen; char *server = NULL; char *share = NULL; struct cli_state *newcli = NULL; char *newpath = NULL; char *newmount = NULL; char *ppath = NULL; SMB_STRUCT_STAT sbuf; uint32 attributes; NTSTATUS status; if ( !rootcli || !path || !targetcli ) { return NT_STATUS_INVALID_PARAMETER; } /* Don't do anything if this is not a DFS root. */ if ( !rootcli->dfsroot) { *targetcli = rootcli; *pp_targetpath = talloc_strdup(ctx, path); if (!*pp_targetpath) { return NT_STATUS_NO_MEMORY; } return NT_STATUS_OK; } *targetcli = NULL; /* Send a trans2_query_path_info to check for a referral. */ cleanpath = clean_path(ctx, path); if (!cleanpath) { return NT_STATUS_NO_MEMORY; } dfs_path = cli_dfs_make_full_path(ctx, rootcli, cleanpath); if (!dfs_path) { return NT_STATUS_NO_MEMORY; } status = cli_qpathinfo_basic( rootcli, dfs_path, &sbuf, &attributes); if (NT_STATUS_IS_OK(status)) { /* This is an ordinary path, just return it. */ *targetcli = rootcli; *pp_targetpath = talloc_strdup(ctx, path); if (!*pp_targetpath) { return NT_STATUS_NO_MEMORY; } goto done; } /* Special case where client asked for a path that does not exist */ if (cli_dfs_check_error(rootcli, NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) { *targetcli = rootcli; *pp_targetpath = talloc_strdup(ctx, path); if (!*pp_targetpath) { return NT_STATUS_NO_MEMORY; } goto done; } /* We got an error, check for DFS referral. */ if (!cli_dfs_check_error(rootcli, NT_STATUS_PATH_NOT_COVERED, status)) { return status; } /* Check for the referral. */ status = cli_cm_open(ctx, rootcli, cli_state_remote_name(rootcli), "IPC$", dfs_auth_info, false, cli_state_encryption_on(rootcli), cli_state_protocol(rootcli), 0, 0x20, &cli_ipc); if (!NT_STATUS_IS_OK(status)) { return status; } status = cli_dfs_get_referral(ctx, cli_ipc, dfs_path, &refs, &num_refs, &consumed); if (!NT_STATUS_IS_OK(status) || !num_refs) { return status; } /* Just store the first referral for now. */ if (!refs[0].dfspath) { return NT_STATUS_NOT_FOUND; } if (!split_dfs_path(ctx, refs[0].dfspath, &server, &share, &extrapath)) { return NT_STATUS_NOT_FOUND; } /* Make sure to recreate the original string including any wildcards. */ dfs_path = cli_dfs_make_full_path(ctx, rootcli, path); if (!dfs_path) { return NT_STATUS_NO_MEMORY; } pathlen = strlen(dfs_path); consumed = MIN(pathlen, consumed); *pp_targetpath = talloc_strdup(ctx, &dfs_path[consumed]); if (!*pp_targetpath) { return NT_STATUS_NO_MEMORY; } dfs_path[consumed] = '\0'; /* * *pp_targetpath is now the unconsumed part of the path. * dfs_path is now the consumed part of the path * (in \server\share\path format). */ /* Open the connection to the target server & share */ status = cli_cm_open(ctx, rootcli, server, share, dfs_auth_info, false, cli_state_encryption_on(rootcli), cli_state_protocol(rootcli), 0, 0x20, targetcli); if (!NT_STATUS_IS_OK(status)) { d_printf("Unable to follow dfs referral [\\%s\\%s]\n", server, share ); return status; } if (extrapath && strlen(extrapath) > 0) { /* EMC Celerra NAS version 5.6.50 (at least) doesn't appear to */ /* put the trailing \ on the path, so to be save we put one in if needed */ if (extrapath[strlen(extrapath)-1] != '\\' && **pp_targetpath != '\\') { *pp_targetpath = talloc_asprintf(ctx, "%s\\%s", extrapath, *pp_targetpath); } else { *pp_targetpath = talloc_asprintf(ctx, "%s%s", extrapath, *pp_targetpath); } if (!*pp_targetpath) { return NT_STATUS_NO_MEMORY; } } /* parse out the consumed mount path */ /* trim off the \server\share\ */ ppath = dfs_path; if (*ppath != '\\') { d_printf("cli_resolve_path: " "dfs_path (%s) not in correct format.\n", dfs_path ); return NT_STATUS_NOT_FOUND; } ppath++; /* Now pointing at start of server name. */ if ((ppath = strchr_m( dfs_path, '\\' )) == NULL) { return NT_STATUS_NOT_FOUND; } ppath++; /* Now pointing at start of share name. */ if ((ppath = strchr_m( ppath+1, '\\' )) == NULL) { return NT_STATUS_NOT_FOUND; } ppath++; /* Now pointing at path component. */ newmount = talloc_asprintf(ctx, "%s\\%s", mountpt, ppath ); if (!newmount) { return NT_STATUS_NOT_FOUND; } cli_set_mntpoint(*targetcli, newmount); /* Check for another dfs referral, note that we are not checking for loops here. */ if (!strequal(*pp_targetpath, "\\") && !strequal(*pp_targetpath, "/")) { status = cli_resolve_path(ctx, newmount, dfs_auth_info, *targetcli, *pp_targetpath, &newcli, &newpath); if (NT_STATUS_IS_OK(status)) { /* * When cli_resolve_path returns true here it's always * returning the complete path in newpath, so we're done * here. */ *targetcli = newcli; *pp_targetpath = newpath; return status; } } done: /* If returning true ensure we return a dfs root full path. */ if ((*targetcli)->dfsroot) { dfs_path = talloc_strdup(ctx, *pp_targetpath); if (!dfs_path) { return NT_STATUS_NO_MEMORY; } *pp_targetpath = cli_dfs_make_full_path(ctx, *targetcli, dfs_path); if (*pp_targetpath == NULL) { return NT_STATUS_NO_MEMORY; } } return NT_STATUS_OK; }
/* do a cldap netlogon query */ int ads_cldap_netlogon(ADS_STRUCT *ads) { int sock; int ret; struct cldap_netlogon_reply reply; const char *target = opt_host ? opt_host : inet_ntoa(ads->ldap_ip); sock = open_udp_socket(target, ads->ldap_port); if (sock == -1) { d_printf("Failed to open udp socket to %s:%u\n", inet_ntoa(ads->ldap_ip), ads->ldap_port); return -1; } ret = send_cldap_netlogon(sock, ads->config.realm, global_myname(), 6); if (ret != 0) { return ret; } ret = recv_cldap_netlogon(sock, &reply); close(sock); if (ret == -1) { return -1; } d_printf("Information for Domain Controller: %s\n\n", ads->config.ldap_server_name); d_printf("Response Type: "); switch (reply.type) { case SAMLOGON_AD_UNK_R: d_printf("SAMLOGON\n"); break; case SAMLOGON_AD_R: d_printf("SAMLOGON_USER\n"); break; default: d_printf("0x%x\n", reply.type); break; } d_printf("GUID: %s\n", smb_uuid_string_static(smb_uuid_unpack_static(reply.guid))); d_printf("Flags:\n" "\tIs a PDC: %s\n" "\tIs a GC of the forest: %s\n" "\tIs an LDAP server: %s\n" "\tSupports DS: %s\n" "\tIs running a KDC: %s\n" "\tIs running time services: %s\n" "\tIs the closest DC: %s\n" "\tIs writable: %s\n" "\tHas a hardware clock: %s\n" "\tIs a non-domain NC serviced by LDAP server: %s\n", (reply.flags & ADS_PDC) ? "yes" : "no", (reply.flags & ADS_GC) ? "yes" : "no", (reply.flags & ADS_LDAP) ? "yes" : "no", (reply.flags & ADS_DS) ? "yes" : "no", (reply.flags & ADS_KDC) ? "yes" : "no", (reply.flags & ADS_TIMESERV) ? "yes" : "no", (reply.flags & ADS_CLOSEST) ? "yes" : "no", (reply.flags & ADS_WRITABLE) ? "yes" : "no", (reply.flags & ADS_GOOD_TIMESERV) ? "yes" : "no", (reply.flags & ADS_NDNC) ? "yes" : "no"); printf("Forest:\t\t\t%s\n", reply.forest); printf("Domain:\t\t\t%s\n", reply.domain); printf("Domain Controller:\t%s\n", reply.hostname); printf("Pre-Win2k Domain:\t%s\n", reply.netbios_domain); printf("Pre-Win2k Hostname:\t%s\n", reply.netbios_hostname); if (*reply.unk) printf("Unk:\t\t\t%s\n", reply.unk); if (*reply.user_name) printf("User name:\t%s\n", reply.user_name); printf("Site Name:\t\t%s\n", reply.site_name); printf("Site Name (2):\t\t%s\n", reply.site_name_2); d_printf("NT Version: %d\n", reply.version); d_printf("LMNT Token: %.2x\n", reply.lmnt_token); d_printf("LM20 Token: %.2x\n", reply.lm20_token); return ret; }
/* receive a cldap netlogon reply */ static int recv_cldap_netlogon(int sock, struct cldap_netlogon_reply *reply) { int ret; ASN1_DATA data; DATA_BLOB blob; DATA_BLOB os1, os2, os3; uint32 i1; char *p; blob = data_blob(NULL, 8192); ret = read(sock, blob.data, blob.length); if (ret <= 0) { d_printf("no reply received to cldap netlogon\n"); return -1; } blob.length = ret; asn1_load(&data, blob); asn1_start_tag(&data, ASN1_SEQUENCE(0)); asn1_read_Integer(&data, &i1); asn1_start_tag(&data, ASN1_APPLICATION(4)); asn1_read_OctetString(&data, &os1); asn1_start_tag(&data, ASN1_SEQUENCE(0)); asn1_start_tag(&data, ASN1_SEQUENCE(0)); asn1_read_OctetString(&data, &os2); asn1_start_tag(&data, ASN1_SET); asn1_read_OctetString(&data, &os3); asn1_end_tag(&data); asn1_end_tag(&data); asn1_end_tag(&data); asn1_end_tag(&data); asn1_end_tag(&data); if (data.has_error) { d_printf("Failed to parse cldap reply\n"); return -1; } p = (char *)os3.data; reply->type = IVAL(p, 0); p += 4; reply->flags = IVAL(p, 0); p += 4; memcpy(&reply->guid.info, p, UUID_FLAT_SIZE); p += UUID_FLAT_SIZE; p += pull_netlogon_string(reply->forest, p, (const char *)os3.data); p += pull_netlogon_string(reply->domain, p, (const char *)os3.data); p += pull_netlogon_string(reply->hostname, p, (const char *)os3.data); p += pull_netlogon_string(reply->netbios_domain, p, (const char *)os3.data); p += pull_netlogon_string(reply->netbios_hostname, p, (const char *)os3.data); p += pull_netlogon_string(reply->unk, p, (const char *)os3.data); if (reply->type == SAMLOGON_AD_R) { p += pull_netlogon_string(reply->user_name, p, (const char *)os3.data); } else { *reply->user_name = 0; } p += pull_netlogon_string(reply->site_name, p, (const char *)os3.data); p += pull_netlogon_string(reply->site_name_2, p, (const char *)os3.data); reply->version = IVAL(p, 0); reply->lmnt_token = SVAL(p, 4); reply->lm20_token = SVAL(p, 6); data_blob_free(&os1); data_blob_free(&os2); data_blob_free(&os3); data_blob_free(&blob); return 0; }
static int errmsg_not_implemented(void) { d_printf("\nNot implemented\n"); return 0; }
/** * i2400m_msg_to_dev - Send a control message to the device and get a response * * @i2400m: device descriptor * * @msg_skb: an skb * * * @buf: pointer to the buffer containing the message to be sent; it * has to start with a &struct i2400M_l3l4_hdr and then * followed by the payload. Once this function returns, the * buffer can be reused. * * @buf_len: buffer size * * Returns: * * Pointer to skb containing the ack message. You need to check the * pointer with IS_ERR(), as it might be an error code. Error codes * could happen because: * * - the message wasn't formatted correctly * - couldn't send the message * - failed waiting for a response * - the ack message wasn't formatted correctly * * The returned skb has been allocated with wimax_msg_to_user_alloc(), * it contains the reponse in a netlink attribute and is ready to be * passed up to user space with wimax_msg_to_user_send(). To access * the payload and its length, use wimax_msg_{data,len}() on the skb. * * The skb has to be freed with kfree_skb() once done. * * Description: * * This function delivers a message/command to the device and waits * for an ack to be received. The format is described in * linux/wimax/i2400m.h. In summary, a command/get/set is followed by an * ack. * * This function will not check the ack status, that's left up to the * caller. Once done with the ack skb, it has to be kfree_skb()ed. * * The i2400m handles only one message at the same time, thus we need * the mutex to exclude other players. * * We write the message and then wait for an answer to come back. The * RX path intercepts control messages and handles them in * i2400m_rx_ctl(). Reports (notifications) are (maybe) processed * locally and then forwarded (as needed) to user space on the WiMAX * stack message pipe. Acks are saved and passed back to us through an * skb in i2400m->ack_skb which is ready to be given to generic * netlink if need be. */ struct sk_buff *i2400m_msg_to_dev(struct i2400m *i2400m, const void *buf, size_t buf_len) { int result; struct device *dev = i2400m_dev(i2400m); const struct i2400m_l3l4_hdr *msg_l3l4_hdr; struct sk_buff *ack_skb; const struct i2400m_l3l4_hdr *ack_l3l4_hdr; size_t ack_len; int ack_timeout; unsigned msg_type; unsigned long flags; d_fnstart(3, dev, "(i2400m %p buf %p len %zu)\n", i2400m, buf, buf_len); if (i2400m->boot_mode) return ERR_PTR(-ENODEV); msg_l3l4_hdr = buf; /* Check msg & payload consistency */ result = i2400m_msg_size_check(i2400m, msg_l3l4_hdr, buf_len); if (result < 0) goto error_bad_msg; msg_type = le16_to_cpu(msg_l3l4_hdr->type); d_printf(1, dev, "CMD/GET/SET 0x%04x %zu bytes\n", msg_type, buf_len); d_dump(2, dev, buf, buf_len); /* Setup the completion, ack_skb ("we are waiting") and send * the message to the device */ mutex_lock(&i2400m->msg_mutex); spin_lock_irqsave(&i2400m->rx_lock, flags); i2400m->ack_skb = ERR_PTR(-EINPROGRESS); spin_unlock_irqrestore(&i2400m->rx_lock, flags); init_completion(&i2400m->msg_completion); result = i2400m_tx(i2400m, buf, buf_len, I2400M_PT_CTRL); if (result < 0) { dev_err(dev, "can't send message 0x%04x: %d\n", le16_to_cpu(msg_l3l4_hdr->type), result); goto error_tx; } /* Some commands take longer to execute because of crypto ops, * so we give them some more leeway on timeout */ switch (msg_type) { case I2400M_MT_GET_TLS_OPERATION_RESULT: case I2400M_MT_CMD_SEND_EAP_RESPONSE: ack_timeout = 5 * HZ; break; default: ack_timeout = HZ; }; /* The RX path in rx.c will put any response for this message * in i2400m->ack_skb and wake us up. If we cancel the wait, * we need to change the value of i2400m->ack_skb to something * not -EINPROGRESS so RX knows there is no one waiting. */ result = wait_for_completion_interruptible_timeout( &i2400m->msg_completion, ack_timeout); if (result == 0) { dev_err(dev, "timeout waiting for reply to message 0x%04x\n", msg_type); result = -ETIMEDOUT; i2400m_msg_to_dev_cancel_wait(i2400m, result); goto error_wait_for_completion; } else if (result < 0) { dev_err(dev, "error waiting for reply to message 0x%04x: %d\n", msg_type, result); i2400m_msg_to_dev_cancel_wait(i2400m, result); goto error_wait_for_completion; } /* Pull out the ack data from i2400m->ack_skb -- see if it is * an error and act accordingly */ spin_lock_irqsave(&i2400m->rx_lock, flags); ack_skb = i2400m->ack_skb; if (IS_ERR(ack_skb)) result = PTR_ERR(ack_skb); else result = 0; i2400m->ack_skb = NULL; spin_unlock_irqrestore(&i2400m->rx_lock, flags); if (result < 0) goto error_ack_status; ack_l3l4_hdr = wimax_msg_data_len(ack_skb, &ack_len); /* Check the ack and deliver it if it is ok */ result = i2400m_msg_size_check(i2400m, ack_l3l4_hdr, ack_len); if (result < 0) { dev_err(dev, "HW BUG? reply to message 0x%04x: %d\n", msg_type, result); goto error_bad_ack_len; } if (msg_type != le16_to_cpu(ack_l3l4_hdr->type)) { dev_err(dev, "HW BUG? bad reply 0x%04x to message 0x%04x\n", le16_to_cpu(ack_l3l4_hdr->type), msg_type); result = -EIO; goto error_bad_ack_type; } i2400m_msg_ack_hook(i2400m, ack_l3l4_hdr, ack_len); mutex_unlock(&i2400m->msg_mutex); d_fnend(3, dev, "(i2400m %p buf %p len %zu) = %p\n", i2400m, buf, buf_len, ack_skb); return ack_skb; error_bad_ack_type: error_bad_ack_len: kfree_skb(ack_skb); error_ack_status: error_wait_for_completion: error_tx: mutex_unlock(&i2400m->msg_mutex); error_bad_msg: d_fnend(3, dev, "(i2400m %p buf %p len %zu) = %d\n", i2400m, buf, buf_len, result); return ERR_PTR(result); }
/*************************************************************************** list info on an open file ***************************************************************************/ static void file_fn(const char * pPath, const char * pUser, uint16 perms, uint16 locks, uint32 id) { d_printf("%-7.1d %-20.20s 0x%-4.2x %-6.1d %s\n", id, pUser, perms, locks, pPath); }
BOOL torture_domain_close_samr(struct torture_context *torture) { BOOL ret = True; NTSTATUS status; TALLOC_CTX *mem_ctx = NULL; struct libnet_context *ctx; struct lsa_String domain_name; struct dcerpc_binding *binding; const char *bindstr; uint32_t access_mask; struct policy_handle h; struct dcerpc_pipe *p; struct libnet_DomainClose r; bindstr = torture_setting_string(torture, "binding", NULL); status = dcerpc_parse_binding(torture, bindstr, &binding); if (!NT_STATUS_IS_OK(status)) { d_printf("failed to parse binding string\n"); return False; } ctx = libnet_context_init(NULL); if (ctx == NULL) { d_printf("failed to create libnet context\n"); ret = False; goto done; } ctx->cred = cmdline_credentials; mem_ctx = talloc_init("torture_domain_close_samr"); status = dcerpc_pipe_connect(mem_ctx, &p, bindstr, &dcerpc_table_samr, ctx->cred, NULL); if (!NT_STATUS_IS_OK(status)) { d_printf("failed to connect to server %s: %s\n", bindstr, nt_errstr(status)); ret = False; goto done; } domain_name.string = lp_workgroup(); if (!test_opendomain_samr(p, torture, &h, &domain_name, &access_mask)) { d_printf("failed to open domain on samr service\n"); ret = False; goto done; } ctx->samr.pipe = p; ctx->samr.name = domain_name.string; ctx->samr.access_mask = access_mask; ctx->samr.handle = h; /* we have to use pipe's event context, otherwise the call will hang indefinitely - this wouldn't be the case if pipe was opened by means of libnet call */ ctx->event_ctx = p->conn->event_ctx; ZERO_STRUCT(r); r.in.type = DOMAIN_SAMR; r.in.domain_name = domain_name.string; status = libnet_DomainClose(ctx, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { ret = False; goto done; } done: talloc_free(mem_ctx); talloc_free(ctx); return ret; }
static void long_group_fn(const char *group_name, const char *comment, void *state) { d_printf("%-21.21s %s\n", group_name, comment); }
BOOL torture_domain_list(struct torture_context *torture) { BOOL ret = True; NTSTATUS status; TALLOC_CTX *mem_ctx = NULL; const char *bindstr; struct dcerpc_binding *binding; struct libnet_context *ctx; struct libnet_DomainList r; int i; bindstr = torture_setting_string(torture, "binding", NULL); status = dcerpc_parse_binding(torture, bindstr, &binding); if (!NT_STATUS_IS_OK(status)) { d_printf("failed to parse binding string\n"); return False; } ctx = libnet_context_init(NULL); if (ctx == NULL) { d_printf("failed to create libnet context\n"); ret = False; goto done; } ctx->cred = cmdline_credentials; mem_ctx = talloc_init("torture_domain_close_samr"); /* * querying the domain list using default buffer size */ ZERO_STRUCT(r); r.in.hostname = binding->host; status = libnet_DomainList(ctx, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { ret = False; goto done; } d_printf("Received list or domains (everything in one piece):\n"); for (i = 0; i < r.out.count; i++) { d_printf("Name[%d]: %s\n", i, r.out.domains[i].name); } /* * querying the domain list using specified (much smaller) buffer size */ ctx->samr.buf_size = 32; ZERO_STRUCT(r); r.in.hostname = binding->host; status = libnet_DomainList(ctx, mem_ctx, &r); if (!NT_STATUS_IS_OK(status)) { ret = False; goto done; } d_printf("Received list or domains (collected in more than one round):\n"); for (i = 0; i < r.out.count; i++) { d_printf("Name[%d]: %s\n", i, r.out.domains[i].name); } done: d_printf("\nStatus: %s\n", nt_errstr(status)); talloc_free(mem_ctx); talloc_free(ctx); return ret; }
static void service_fn(const char *service_name, const char *dummy, void *state) { d_printf("%-21.21s\n", service_name); }
static void _GraphicsPostscript_cellArrayOrImage (GraphicsPostscript me, double **z_float, double_rgbt **z_rgbt, unsigned char **z_byte, long ix1, long ix2, long x1DC, long x2DC, long iy1, long iy2, long y1DC, long y2DC, double minimum, double maximum, long clipx1, long clipx2, long clipy1, long clipy2, int interpolate) { long interpolateX = 1, interpolateY = 1; long nx = ix2 - ix1 + 1, ny = iy2 - iy1 + 1, filling = 0; double scale = ( my photocopyable ? 200.1f : 255.1f ) / (maximum - minimum); double offset = 255.1f + minimum * scale; int minimalGrey = my photocopyable ? 55 : 0; my d_printf (my d_file, "gsave N %ld %ld M %ld %ld L %ld %ld L %ld %ld L closepath clip\n", clipx1, clipy1, clipx2 - clipx1, 0L, 0L, clipy2 - clipy1, clipx1 - clipx2, 0L); my d_printf (my d_file, "%ld %ld translate %ld %ld scale\n", x1DC, y1DC, x2DC - x1DC, y2DC - y1DC); if (interpolate) { /* The smallest image resolution is 300 dpi. If a sample takes up more than 25.4/300 mm, the 300 dpi resolution is achieved by interpolation. */ const double smallestImageResolution = 300.0; double colSize_pixels = (double) (x2DC - x1DC) / nx; double rowSize_pixels = (double) (y2DC - y1DC) / ny; double colSize_inches = colSize_pixels / my resolution; double rowSize_inches = rowSize_pixels / my resolution; interpolateX = ceil (colSize_inches * smallestImageResolution); // number of interpolation points per horizontal sample interpolateY = ceil (rowSize_inches * smallestImageResolution); // number of interpolation points per vertical sample } if (interpolateX <= 1 && interpolateY <= 1) { /* Do not interpolate. */ my d_printf (my d_file, "/picstr %ld string def %ld %ld 8 [%ld 0 0 %ld 0 0]\n" "{ currentfile picstr readhexstring pop } image\n", nx, nx, ny, nx, ny); } else if (interpolateX > 1 && interpolateY > 1) { /* Interpolate both horizontally and vertically. */ long nx_new = nx * interpolateX; long ny_new = ny * interpolateY; /* Interpolation between rows requires us to remember two original rows: */ my d_printf (my d_file, "/lorow %ld string def /hirow %ld string def\n", nx, nx); /* New rows (scanlines) are longer: */ my d_printf (my d_file, "/scanline %ld string def\n", nx_new); /* The first four arguments to the 'image' command, */ /* namely the new number of columns, the new number of rows, the bit depth, and the matrix: */ my d_printf (my d_file, "%ld %ld 8 [%ld 0 0 %ld 0 0]\n", nx_new, ny_new, nx_new, ny_new); /* Since our imageproc is going to output only one scanline at a time, */ /* the outer loop variable (scanline number) has to be initialized outside the imageproc: */ my d_printf (my d_file, "/irow 0 def\n"); /* The imageproc starts here. First, we fill one or two original rows if necessary; */ /* they are read as hexadecimal strings from the current file, i.e. just after the image command. */ my d_printf (my d_file, "{\n" /* First test: are we in the first scanline? If so, read two original rows: */ "irow 0 eq { currentfile lorow readhexstring pop pop lorow hirow copy pop } if\n" /* Second test: did we just pass an original data row? */ /* If so, */ /* (1) move that row backwards; */ /* (2) read a new one unless we just passed the last original row: */ "irow %ld mod %ld eq { hirow lorow copy pop\n" "irow %ld ne { currentfile hirow readhexstring pop pop } if } if\n", interpolateY, interpolateY / 2, ny_new - interpolateY + interpolateY / 2); /* Where are we between those two rows? */ my d_printf (my d_file, "/rowphase irow %ld add %ld mod %ld div def\n", interpolateY - interpolateY / 2, interpolateY, interpolateY); /* Inner loop starts here. It cycles through all new columns: */ my d_printf (my d_file, "0 1 %ld {\n", nx_new - 1); /* Get the inner loop variable: */ my d_printf (my d_file, " /icol exch def\n"); /* Where are the two original columns? */ my d_printf (my d_file, " /locol icol %ld sub %ld idiv def\n", interpolateX / 2, interpolateX); my d_printf (my d_file, " /hicol icol %ld ge { %ld } { icol %ld add %ld idiv } ifelse def\n", nx_new - interpolateX / 2, nx - 1, interpolateX / 2, interpolateX); /* Where are we between those two columns? */ my d_printf (my d_file, " /colphase icol %ld add %ld mod %ld div def\n", interpolateX - interpolateX / 2, interpolateX, interpolateX); /* Four-point interpolation: */ my d_printf (my d_file, " /plow lorow locol get def\n" " /phigh lorow hicol get def\n" " /qlow hirow locol get def\n" " /qhigh hirow hicol get def\n" " /value\n" " plow phigh plow sub colphase mul add 1 rowphase sub mul\n" " qlow qhigh qlow sub colphase mul add rowphase mul\n" " add def\n" " scanline icol value 0 le { 0 } { value 255 ge { 255 } { value } ifelse } ifelse cvi put\n" "} for\n" "/irow irow 1 add def scanline } image\n"); } else if (interpolateX > 1) { /* Interpolate horizontally only. */ long nx_new = nx * interpolateX; /* Remember one original row: */ my d_printf (my d_file, "/row %ld string def\n", nx, nx); /* New rows (scanlines) are longer: */ my d_printf (my d_file, "/scanline %ld string def\n", nx_new); /* The first four arguments to the 'image' command, */ /* namely the new number of columns, the number of rows, the bit depth, and the matrix: */ my d_printf (my d_file, "%ld %ld 8 [%ld 0 0 %ld 0 0]\n", nx_new, ny, nx_new, ny); /* The imageproc starts here. We fill one original row. */ my d_printf (my d_file, "{\n" "currentfile row readhexstring pop pop\n"); /* Loop starts here. It cycles through all new columns: */ my d_printf (my d_file, "0 1 %ld {\n", nx_new - 1); /* Get the loop variable: */ my d_printf (my d_file, " /icol exch def\n"); /* Where are the two original columns? */ my d_printf (my d_file, " /locol icol %ld sub %ld idiv def\n", interpolateX / 2, interpolateX); my d_printf (my d_file, " /hicol icol %ld ge { %ld } { icol %ld add %ld idiv } ifelse def\n", nx_new - interpolateX / 2, nx - 1, interpolateX / 2, interpolateX); /* Where are we between those two columns? */ my d_printf (my d_file, " /colphase icol %ld add %ld mod %ld div def\n", interpolateX - interpolateX / 2, interpolateX, interpolateX); /* Two-point interpolation: */ my d_printf (my d_file, " /plow row locol get def\n" " /phigh row hicol get def\n" " /value plow phigh plow sub colphase mul add def\n" " scanline icol value 0 le { 0 } { value 255 ge { 255 } { value } ifelse } ifelse cvi put\n" "} for\n" "scanline } image\n"); } else { /* Interpolate vertically only. */ long ny_new = ny * interpolateY; /* Interpolation between rows requires us to remember two original rows: */ my d_printf (my d_file, "/lorow %ld string def /hirow %ld string def\n", nx, nx); /* New rows (scanlines) are equally long: */ my d_printf (my d_file, "/scanline %ld string def\n", nx); /* The first four arguments to the 'image' command, */ /* namely the number of columns, the new number of rows, the bit depth, and the matrix: */ my d_printf (my d_file, "%ld %ld 8 [%ld 0 0 %ld 0 0]\n", nx, ny_new, nx, ny_new); /* Since our imageproc is going to output only one scanline at a time, */ /* the outer loop variable (scanline number) has to be initialized outside the imageproc: */ my d_printf (my d_file, "/irow 0 def\n"); /* The imageproc starts here. First, we fill one or two original rows if necessary; */ /* they are read as hexadecimal strings from the current file, i.e. just after the image command. */ my d_printf (my d_file, "{\n" /* First test: are we in the first scanline? If so, read two original rows: */ "irow 0 eq { currentfile lorow readhexstring pop pop lorow hirow copy pop } if\n" /* Second test: did we just pass an original data row? */ /* If so, */ /* (1) move that row backwards; */ /* (2) read a new one unless we just passed the last original row: */ "irow %ld mod %ld eq { hirow lorow copy pop\n" "irow %ld ne { currentfile hirow readhexstring pop pop } if } if\n", interpolateY, interpolateY / 2, ny_new - interpolateY + interpolateY / 2); /* Where are we between those two rows? */ my d_printf (my d_file, "/rowphase irow %ld add %ld mod %ld div def\n", interpolateY - interpolateY / 2, interpolateY, interpolateY); /* Inner loop starts here. It cycles through all columns: */ my d_printf (my d_file, "0 1 %ld {\n", nx - 1); /* Get the inner loop variable: */ my d_printf (my d_file, " /icol exch def\n"); /* Two-point interpolation: */ my d_printf (my d_file, " /p lorow icol get def\n" " /q hirow icol get def\n" " /value\n" " p 1 rowphase sub mul\n" " q rowphase mul\n" " add def\n" " scanline icol value 0 le { 0 } { value 255 ge { 255 } { value } ifelse } ifelse cvi put\n" "} for\n" "/irow irow 1 add def scanline } image\n"); } for (long iy = iy1; iy <= iy2; iy ++) for (long ix = ix1; ix <= ix2; ix ++) { int value = (int) (offset - scale * ( z_float ? z_float [iy] [ix] : z_byte [iy] [ix] )); my d_printf (my d_file, "%.2x", value <= minimalGrey ? minimalGrey : value >= 255 ? 255 : value); if (++ filling == 39) { my d_printf (my d_file, "\n"); filling = 0; } } if (filling) my d_printf (my d_file, "\n"); my d_printf (my d_file, "grestore\n"); }
/* Initialize the BT-9X8 and confirm that it is operating as expected */ static long init_buslogic(BusLogic *bl) { uchar status; uchar id[16]; int i; char *str = bl->productname; d_printf("buslogic: init_buslogic()\n"); dprintf("buslogic: reset: "); outb(BL_CONTROL_REG, BL_CONTROL_RHARD); spin(10000); /* give the controller some time to settle down from reset */ for(i=0; i<1000; i++) { spin(100000); status = inb(BL_STATUS_REG); if(status & BL_STATUS_DACT) { dprintf("."); continue; } if(status & BL_STATUS_DFAIL) { dprintf(" FAILED\n"); return -1; } if(status & BL_STATUS_INREQ) { dprintf(" OKAY\n"); break; } if(status & BL_STATUS_HARDY) { dprintf(" READY\n"); break; } } if(i==100) { dprintf(" TIMEOUT\n"); return -1; } if(bl_execute(bl, 0x04, NULL, 0, id, 4)) { d_printf("buslogic: can't id?\n"); return B_ERROR; } d_printf("buslogic: Firmware Rev %c.%c\n",id[2],id[3]); id[0]=14; id[14]=id[2]; if(bl_execute(bl, 0x8d, id, 1, id, 14)) { d_printf("buslogic: cannot read extended config\n"); return B_ERROR; } d_printf("buslogic: rev = %c.%c%c%c mb = %d, sgmax = %d, flags = 0x%02x\n", id[14], id[10], id[11], id[12], id[4], id[2] | (id[3]<<8), id[13]); if(id[13] & 0x01) bl->wide = 1; else bl->wide = 0; if(id[14] == '5') { *str++ = 'B'; *str++ = 'T'; *str++ = '-'; *str++ = '9'; *str++ = bl->wide ? '5' : '4'; *str++ = '8'; if(id[13] & 0x02) *str++ = 'D'; *str++ = ' '; *str++ = 'v'; *str++ = id[14]; *str++ = '.'; *str++ = id[10]; *str++ = id[11]; *str++ = id[12]; *str++ = 0; } else { strcpy(str,"unknown"); } if(bl_execute(bl, 0x0B, NULL, 0, id, 3)) { d_printf("buslogic: cannot read config\n"); return B_ERROR; } bl->scsi_id = id[2]; d_printf("buslogic: Adapter SCSI ID = %d\n",bl->scsi_id); if(install_io_interrupt_handler(bl->irq, scsi_int_dispatch, bl, 0) == B_ERROR) d_printf("buslogic: can't install irq handler\n"); /* are we getting INTs? */ bl->done = 0; spin(10000); outb(BL_COMMAND_REG, 0x00); spin(1000000); if(bl->done) { d_printf("buslogic: interrupt test passed\n"); } else { d_printf("buslogic: interrupt test failed\n"); return B_ERROR; } /* strict round-robin on */ id[0] = 0; if(bl_execute(bl,0x8F, id, 1, NULL, 0)) { d_printf("buslogic: cannot enable strict round-robin mode\n"); return B_ERROR; } id[0] = bl->box_count; { int mbaddr = toLE(bl->phys_mailboxes); memcpy(id + 1, &(mbaddr),4); } if(bl_execute(bl, 0x81, id, 5, NULL, 0)) { d_printf("buslogic: cannot init mailboxes\n"); return B_ERROR; } d_printf("buslogic: %d mailboxes @ 0x%08xv/0x%08lxp\n", bl->box_count, (uint) bl->out_boxes, bl->phys_mailboxes); return B_NO_ERROR; }
static void long_share_fn(const char *share_name, uint32 type, const char *comment, void *state) { d_printf("%-12s %-8.8s %-50s\n", share_name, share_type[type], comment); }
ssize_t SMBC_read_ctx(SMBCCTX *context, SMBCFILE *file, void *buf, size_t count) { size_t ret; char *server = NULL, *share = NULL, *user = NULL, *password = NULL; char *path = NULL; char *targetpath = NULL; struct cli_state *targetcli = NULL; TALLOC_CTX *frame = talloc_stackframe(); NTSTATUS status; /* * offset: * * Compiler bug (possibly) -- gcc (GCC) 3.3.5 (Debian 1:3.3.5-2) -- * appears to pass file->offset (which is type off_t) differently than * a local variable of type off_t. Using local variable "offset" in * the call to cli_read() instead of file->offset fixes a problem * retrieving data at an offset greater than 4GB. */ off_t offset; if (!context || !context->internal->initialized) { errno = EINVAL; TALLOC_FREE(frame); return -1; } DEBUG(4, ("smbc_read(%p, %d)\n", file, (int)count)); if (!file || !SMBC_dlist_contains(context->internal->files, file)) { errno = EBADF; TALLOC_FREE(frame); return -1; } offset = file->offset; /* Check that the buffer exists ... */ if (buf == NULL) { errno = EINVAL; TALLOC_FREE(frame); return -1; } /*d_printf(">>>read: parsing %s\n", file->fname);*/ if (SMBC_parse_path(frame, context, file->fname, NULL, &server, &share, &path, &user, &password, NULL)) { errno = EINVAL; TALLOC_FREE(frame); return -1; } /*d_printf(">>>read: resolving %s\n", path);*/ status = cli_resolve_path(frame, "", context->internal->auth_info, file->srv->cli, path, &targetcli, &targetpath); if (!NT_STATUS_IS_OK(status)) { d_printf("Could not resolve %s\n", path); errno = ENOENT; TALLOC_FREE(frame); return -1; } /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/ status = cli_read(targetcli, file->cli_fd, (char *)buf, offset, count, &ret); if (!NT_STATUS_IS_OK(status)) { errno = SMBC_errno(context, targetcli); TALLOC_FREE(frame); return -1; } file->offset += ret; DEBUG(4, (" --> %ld\n", (unsigned long)ret)); TALLOC_FREE(frame); return ret; /* Success, ret bytes of data ... */ }
static void share_fn(const char *share_name, uint32 type, const char *comment, void *state) { d_printf("%s\n", share_name); }
SMBCFILE * SMBC_open_ctx(SMBCCTX *context, const char *fname, int flags, mode_t mode) { char *server = NULL; char *share = NULL; char *user = NULL; char *password = NULL; char *workgroup = NULL; char *path = NULL; char *targetpath = NULL; struct cli_state *targetcli = NULL; SMBCSRV *srv = NULL; SMBCFILE *file = NULL; uint16_t fd; NTSTATUS status = NT_STATUS_OBJECT_PATH_INVALID; TALLOC_CTX *frame = talloc_stackframe(); if (!context || !context->internal->initialized) { errno = EINVAL; /* Best I can think of ... */ TALLOC_FREE(frame); return NULL; } if (!fname) { errno = EINVAL; TALLOC_FREE(frame); return NULL; } if (SMBC_parse_path(frame, context, fname, &workgroup, &server, &share, &path, &user, &password, NULL)) { errno = EINVAL; TALLOC_FREE(frame); return NULL; } if (!user || user[0] == (char)0) { user = talloc_strdup(frame, smbc_getUser(context)); if (!user) { errno = ENOMEM; TALLOC_FREE(frame); return NULL; } } srv = SMBC_server(frame, context, True, server, share, &workgroup, &user, &password); if (!srv) { if (errno == EPERM) errno = EACCES; TALLOC_FREE(frame); return NULL; /* SMBC_server sets errno */ } /* Hmmm, the test for a directory is suspect here ... FIXME */ if (strlen(path) > 0 && path[strlen(path) - 1] == '\\') { status = NT_STATUS_OBJECT_PATH_INVALID; } else { file = SMB_MALLOC_P(SMBCFILE); if (!file) { errno = ENOMEM; TALLOC_FREE(frame); return NULL; } ZERO_STRUCTP(file); /*d_printf(">>>open: resolving %s\n", path);*/ status = cli_resolve_path( frame, "", context->internal->auth_info, srv->cli, path, &targetcli, &targetpath); if (!NT_STATUS_IS_OK(status)) { d_printf("Could not resolve %s\n", path); errno = ENOENT; SAFE_FREE(file); TALLOC_FREE(frame); return NULL; } /*d_printf(">>>open: resolved %s as %s\n", path, targetpath);*/ status = cli_open(targetcli, targetpath, flags, context->internal->share_mode, &fd); if (!NT_STATUS_IS_OK(status)) { /* Handle the error ... */ SAFE_FREE(file); errno = SMBC_errno(context, targetcli); TALLOC_FREE(frame); return NULL; } /* Fill in file struct */ file->cli_fd = fd; file->fname = SMB_STRDUP(fname); file->srv = srv; file->offset = 0; file->file = True; DLIST_ADD(context->internal->files, file); /* * If the file was opened in O_APPEND mode, all write * operations should be appended to the file. To do that, * though, using this protocol, would require a getattrE() * call for each and every write, to determine where the end * of the file is. (There does not appear to be an append flag * in the protocol.) Rather than add all of that overhead of * retrieving the current end-of-file offset prior to each * write operation, we'll assume that most append operations * will continuously write, so we'll just set the offset to * the end of the file now and hope that's adequate. * * Note to self: If this proves inadequate, and O_APPEND * should, in some cases, be forced for each write, add a * field in the context options structure, for * "strict_append_mode" which would select between the current * behavior (if FALSE) or issuing a getattrE() prior to each * write and forcing the write to the end of the file (if * TRUE). Adding that capability will likely require adding * an "append" flag into the _SMBCFILE structure to track * whether a file was opened in O_APPEND mode. -- djl */ if (flags & O_APPEND) { if (SMBC_lseek_ctx(context, file, 0, SEEK_END) < 0) { (void) SMBC_close_ctx(context, file); errno = ENXIO; TALLOC_FREE(frame); return NULL; } } TALLOC_FREE(frame); return file; } /* Check if opendir needed ... */ if (!NT_STATUS_IS_OK(status)) { int eno = 0; eno = SMBC_errno(context, srv->cli); file = smbc_getFunctionOpendir(context)(context, fname); if (!file) errno = eno; TALLOC_FREE(frame); return file; } errno = EINVAL; /* FIXME, correct errno ? */ TALLOC_FREE(frame); return NULL; }
/**************************************************************************** list a server name ****************************************************************************/ static void display_server_func(const char *name, uint32 m, const char *comment, void * reserved) { d_printf("\t%-16.16s %s\n", name, comment); }
/* * Get info from an SMB server on a file. Use a qpathinfo call first * and if that fails, use getatr, as Win95 sometimes refuses qpathinfo */ bool SMBC_getatr(SMBCCTX * context, SMBCSRV *srv, const char *path, uint16 *mode, off_t *size, struct timespec *create_time_ts, struct timespec *access_time_ts, struct timespec *write_time_ts, struct timespec *change_time_ts, SMB_INO_T *ino) { char *fixedpath = NULL; char *targetpath = NULL; struct cli_state *targetcli = NULL; time_t write_time; TALLOC_CTX *frame = talloc_stackframe(); NTSTATUS status; if (!context || !context->internal->initialized) { errno = EINVAL; TALLOC_FREE(frame); return False; } /* path fixup for . and .. */ if (strequal(path, ".") || strequal(path, "..")) { fixedpath = talloc_strdup(frame, "\\"); if (!fixedpath) { errno = ENOMEM; TALLOC_FREE(frame); return False; } } else { fixedpath = talloc_strdup(frame, path); if (!fixedpath) { errno = ENOMEM; TALLOC_FREE(frame); return False; } trim_string(fixedpath, NULL, "\\.."); trim_string(fixedpath, NULL, "\\."); } DEBUG(4,("SMBC_getatr: sending qpathinfo\n")); status = cli_resolve_path(frame, "", context->internal->auth_info, srv->cli, fixedpath, &targetcli, &targetpath); if (!NT_STATUS_IS_OK(status)) { d_printf("Couldn't resolve %s\n", path); errno = ENOENT; TALLOC_FREE(frame); return False; } if (!srv->no_pathinfo2 && NT_STATUS_IS_OK(cli_qpathinfo2(targetcli, targetpath, create_time_ts, access_time_ts, write_time_ts, change_time_ts, size, mode, ino))) { TALLOC_FREE(frame); return True; } /* if this is NT then don't bother with the getatr */ if (cli_state_capabilities(targetcli) & CAP_NT_SMBS) { errno = EPERM; TALLOC_FREE(frame); return False; } if (NT_STATUS_IS_OK(cli_getatr(targetcli, targetpath, mode, size, &write_time))) { struct timespec w_time_ts; w_time_ts = convert_time_t_to_timespec(write_time); if (write_time_ts != NULL) { *write_time_ts = w_time_ts; } if (create_time_ts != NULL) { *create_time_ts = w_time_ts; } if (access_time_ts != NULL) { *access_time_ts = w_time_ts; } if (change_time_ts != NULL) { *change_time_ts = w_time_ts; } srv->no_pathinfo2 = True; TALLOC_FREE(frame); return True; } errno = EPERM; TALLOC_FREE(frame); return False; }
static void filter_request(char *buf, size_t buf_len) { int msg_type = CVAL(buf,0); int type = CVAL(buf,smb_com); unsigned x; fstring name1,name2; int name_len1 = 0; int name_len2; int name_type1, name_type2; int ret; if (msg_type) { /* it's a netbios special */ switch (msg_type) case 0x81: /* session request */ /* inbuf_size is guaranteed to be at least 4. */ name_len1 = name_len((unsigned char *)(buf+4), buf_len - 4); if (name_len1 <= 0 || name_len1 > buf_len - 4) { DEBUG(0,("Invalid name length in session request\n")); return; } name_len2 = name_len((unsigned char *)(buf+4+name_len1), buf_len - 4 - name_len1); if (name_len2 <= 0 || name_len2 > buf_len - 4 - name_len1) { DEBUG(0,("Invalid name length in session request\n")); return; } name_type1 = name_extract((unsigned char *)buf, buf_len,(unsigned int)4,name1); name_type2 = name_extract((unsigned char *)buf, buf_len,(unsigned int)(4 + name_len1),name2); if (name_type1 == -1 || name_type2 == -1) { DEBUG(0,("Invalid name type in session request\n")); return; } d_printf("sesion_request: %s -> %s\n", name1, name2); if (netbiosname) { char *mangled = name_mangle( talloc_tos(), netbiosname, 0x20); if (mangled != NULL) { /* replace the destination netbios * name */ memcpy(buf+4, mangled, name_len((unsigned char *)mangled, talloc_get_size(mangled))); TALLOC_FREE(mangled); } } return; } /* it's an ordinary SMB request */ switch (type) { case SMBsesssetupX: /* force the client capabilities */ x = IVAL(buf,smb_vwv11); d_printf("SMBsesssetupX cap=0x%08x\n", x); d_printf("pwlen=%d/%d\n", SVAL(buf, smb_vwv7), SVAL(buf, smb_vwv8)); ret = system("mv sessionsetup.dat sessionsetup1.dat"); if (ret == -1) { DBG_ERR("failed to call mv command\n"); } save_file("sessionsetup.dat", smb_buf(buf), SVAL(buf, smb_vwv7)); x = (x | CLI_CAPABILITY_SET) & ~CLI_CAPABILITY_MASK; SIVAL(buf, smb_vwv11, x); break; } }