smb.c - OpenGrok cross reference for /third

Lines Matching refs:data
52  * Definitions for SMB protocol data structures
245 static CURLcode smb_setup_connection(struct Curl_easy *data,
247 static CURLcode smb_connect(struct Curl_easy *data, bool *done);
248 static CURLcode smb_connection_state(struct Curl_easy *data, bool *done);
249 static CURLcode smb_do(struct Curl_easy *data, bool *done);
250 static CURLcode smb_request_state(struct Curl_easy *data, bool *done);
251 static CURLcode smb_disconnect(struct Curl_easy *data,
253 static int smb_getsock(struct Curl_easy *data, struct connectdata *conn,
255 static CURLcode smb_parse_url_path(struct Curl_easy *data,
369 /* SMB request data */
378 static void conn_state(struct Curl_easy *data, enum smb_conn_state newstate)
380   struct smb_conn *smbc = &data->conn->proto.smbc;
393     infof(data, "SMB conn %p state change from %s to %s",
400 static void request_state(struct Curl_easy *data,
403   struct smb_request *req = data->req.p.smb;
419     infof(data, "SMB request %p state change from %s to %s",
428 static CURLcode smb_setup_connection(struct Curl_easy *data,
434   data->req.p.smb = req = calloc(1, sizeof(struct smb_request));
439   return smb_parse_url_path(data, conn);
442 static CURLcode smb_connect(struct Curl_easy *data, bool *done)
444   struct connectdata *conn = data->conn;
451   if(!data->state.aptr.user)
485 static CURLcode smb_recv_message(struct Curl_easy *data, void **msg)
487   struct connectdata *conn = data->conn;
497   result = Curl_read(data, sockfd, buf + smbc->got, len, &bytes_read);
541 static void smb_format_message(struct Curl_easy *data, struct smb_header *h,
544   struct connectdata *conn = data->conn;
546   struct smb_request *req = data->req.p.smb;
563 static CURLcode smb_send(struct Curl_easy *data, ssize_t len,
566   struct connectdata *conn = data->conn;
571   result = Curl_nwrite(data, FIRSTSOCKET, data->state.ulbuf,
586 static CURLcode smb_flush(struct Curl_easy *data)
588   struct connectdata *conn = data->conn;
597   result = Curl_nwrite(data, FIRSTSOCKET,
598                        data->state.ulbuf + smbc->sent,
611 static CURLcode smb_send_message(struct Curl_easy *data, unsigned char cmd,
614   CURLcode result = Curl_get_upload_buffer(data);
617   smb_format_message(data, (struct smb_header *)data->state.ulbuf,
619   memcpy(data->state.ulbuf + sizeof(struct smb_header),
622   return smb_send(data, sizeof(struct smb_header) + msg_len, 0);
625 static CURLcode smb_send_negotiate(struct Curl_easy *data)
629   return smb_send_message(data, SMB_COM_NEGOTIATE, msg, 15);
632 static CURLcode smb_send_setup(struct Curl_easy *data)
634   struct connectdata *conn = data->conn;
675   return smb_send_message(data, SMB_COM_SETUP_ANDX, &msg,
679 static CURLcode smb_send_tree_connect(struct Curl_easy *data)
682   struct connectdata *conn = data->conn;
703   return smb_send_message(data, SMB_COM_TREE_CONNECT_ANDX, &msg,
707 static CURLcode smb_send_open(struct Curl_easy *data)
709   struct smb_request *req = data->req.p.smb;
722   if(data->state.upload) {
733   return smb_send_message(data, SMB_COM_NT_CREATE_ANDX, &msg,
737 static CURLcode smb_send_close(struct Curl_easy *data)
739   struct smb_request *req = data->req.p.smb;
746   return smb_send_message(data, SMB_COM_CLOSE, &msg, sizeof(msg));
749 static CURLcode smb_send_tree_disconnect(struct Curl_easy *data)
755   return smb_send_message(data, SMB_COM_TREE_DISCONNECT, &msg, sizeof(msg));
758 static CURLcode smb_send_read(struct Curl_easy *data)
760   struct smb_request *req = data->req.p.smb;
761   curl_off_t offset = data->req.offset;
773   return smb_send_message(data, SMB_COM_READ_ANDX, &msg, sizeof(msg));
776 static CURLcode smb_send_write(struct Curl_easy *data)
779   struct smb_request *req = data->req.p.smb;
780   curl_off_t offset = data->req.offset;
781   curl_off_t upload_size = data->req.size - data->req.bytecount;
782   CURLcode result = Curl_get_upload_buffer(data);
785   msg = (struct smb_write *)data->state.ulbuf;
800   smb_format_message(data, &msg->h, SMB_COM_WRITE_ANDX,
803   return smb_send(data, sizeof(*msg), (size_t) upload_size);
806 static CURLcode smb_send_and_recv(struct Curl_easy *data, void **msg)
808   struct connectdata *conn = data->conn;
813   /* Check if there is data in the transfer buffer */
815     size_t nread = smbc->upload_size > (size_t)data->set.upload_buffer_size ?
816       (size_t)data->set.upload_buffer_size : smbc->upload_size;
817     data->req.upload_fromhere = data->state.ulbuf;
818     result = Curl_fillreadbuffer(data, nread, &nread);
829   /* Check if there is data to send */
831     result = smb_flush(data);
836   /* Check if there is still data to be sent */
840   return smb_recv_message(data, msg);
843 static CURLcode smb_connection_state(struct Curl_easy *data, bool *done)
845   struct connectdata *conn = data->conn;
856       result = Curl_conn_connect(data, FIRSTSOCKET, FALSE, &ssl_done);
864     result = smb_send_negotiate(data);
870     conn_state(data, SMB_NEGOTIATE);
874   result = smb_send_and_recv(data, &msg);
895     result = smb_send_setup(data);
900     conn_state(data, SMB_SETUP);
909     conn_state(data, SMB_CONNECTED);
941 static CURLcode smb_request_state(struct Curl_easy *data, bool *done)
943   struct connectdata *conn = data->conn;
944   struct smb_request *req = data->req.p.smb;
954   if(data->state.upload && (data->state.infilesize < 0)) {
955     failf(data, "SMB upload needs to know the size up front");
961     result = smb_send_tree_connect(data);
967     request_state(data, SMB_TREE_CONNECT);
971   result = smb_send_and_recv(data, &msg);
1004     data->req.offset = 0;
1005     if(data->state.upload) {
1006       data->req.size = data->state.infilesize;
1007       Curl_pgrsSetUploadSize(data, data->req.size);
1011       data->req.size = smb_swap64(smb_m->end_of_file);
1012       if(data->req.size < 0) {
1017         Curl_pgrsSetDownloadSize(data, data->req.size);
1018         if(data->set.get_filetime)
1019           get_posix_time(&data->info.filetime, smb_m->last_change_time);
1037         failf(data, "Invalid input packet");
1041         result = Curl_client_write(data, CLIENTWRITE_BODY,
1050     data->req.offset += len;
1062     data->req.bytecount += len;
1063     data->req.offset += len;
1064     Curl_pgrsSetUploadCounter(data, data->req.bytecount);
1065     if(data->req.bytecount >= data->req.size)
1089     result = smb_send_open(data);
1093     result = smb_send_read(data);
1097     result = smb_send_write(data);
1101     result = smb_send_close(data);
1105     result = smb_send_tree_disconnect(data);
1122   request_state(data, next_state);
1127 static CURLcode smb_disconnect(struct Curl_easy *data,
1132   (void) data;
1139 static int smb_getsock(struct Curl_easy *data,
1142   (void)data;
1147 static CURLcode smb_do(struct Curl_easy *data, bool *done)
1149   struct connectdata *conn = data->conn;
1159 static CURLcode smb_parse_url_path(struct Curl_easy *data,
1162   struct smb_request *req = data->req.p.smb;
1168   CURLcode result = Curl_urldecode(data->state.up.path, 0, &path, NULL,
1186     failf(data, "missing share in URL path for SMB");