/* {{{ mysqlnd_net::read_compressed_packet_from_stream_and_fill_read_buffer */ static enum_func_status MYSQLND_METHOD(mysqlnd_net, read_compressed_packet_from_stream_and_fill_read_buffer) (MYSQLND_NET * net, size_t net_payload_size, MYSQLND_STATS * conn_stats, MYSQLND_ERROR_INFO * error_info) { size_t decompressed_size; enum_func_status retval = PASS; zend_uchar * compressed_data = NULL; zend_uchar comp_header[COMPRESSED_HEADER_SIZE]; DBG_ENTER("mysqlnd_net::read_compressed_packet_from_stream_and_fill_read_buffer"); /* Read the compressed header */ if (FAIL == net->data->m.network_read_ex(net, comp_header, COMPRESSED_HEADER_SIZE, conn_stats, error_info)) { DBG_RETURN(FAIL); } decompressed_size = uint3korr(comp_header); /* When decompressed_size is 0, then the data is not compressed, and we have wasted 3 bytes */ /* we need to decompress the data */ if (decompressed_size) { compressed_data = mnd_emalloc(net_payload_size); if (FAIL == net->data->m.network_read_ex(net, compressed_data, net_payload_size, conn_stats, error_info)) { retval = FAIL; goto end; } net->uncompressed_data = mysqlnd_create_read_buffer(decompressed_size); retval = net->data->m.decode(net->uncompressed_data->data, decompressed_size, compressed_data, net_payload_size); if (FAIL == retval) { goto end; } } else { DBG_INF_FMT("The server decided not to compress the data. Our job is easy. Copying %u bytes", net_payload_size); net->uncompressed_data = mysqlnd_create_read_buffer(net_payload_size); if (FAIL == net->data->m.network_read_ex(net, net->uncompressed_data->data, net_payload_size, conn_stats, error_info)) { retval = FAIL; goto end; } } end: if (compressed_data) { mnd_efree(compressed_data); } DBG_RETURN(retval); }
/* {{{ mysqlnd_com_init_db_run */ static enum_func_status mysqlnd_com_init_db_run(void *cmd) { struct st_mysqlnd_protocol_com_init_db_command * command = (struct st_mysqlnd_protocol_com_init_db_command *) cmd; enum_func_status ret = FAIL; MYSQLND_CONN_DATA * conn = command->context.conn; const MYSQLND_CSTRING db = command->context.db; func_mysqlnd_protocol_payload_decoder_factory__send_command send_command = conn->payload_decoder_factory->m.send_command; func_mysqlnd_protocol_payload_decoder_factory__send_command_handle_response send_command_handle_response = conn->payload_decoder_factory->m.send_command_handle_response; DBG_ENTER("mysqlnd_com_init_db_run"); ret = send_command(conn->payload_decoder_factory, COM_INIT_DB, (zend_uchar*) command->context.db.s, command->context.db.l, FALSE, &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->m->send_close, conn); if (PASS == ret) { ret = send_command_handle_response(conn->payload_decoder_factory, PROT_OK_PACKET, FALSE, COM_INIT_DB, TRUE, conn->error_info, conn->upsert_status, &conn->last_message, conn->persistent); } /* The server sends 0 but libmysql doesn't read it and has established a protocol of giving back -1. Thus we have to follow it :( */ UPSERT_STATUS_SET_AFFECTED_ROWS_TO_ERROR(conn->upsert_status); if (ret == PASS) { if (conn->connect_or_select_db.s) { mnd_pefree(conn->connect_or_select_db.s, conn->persistent); } conn->connect_or_select_db.s = mnd_pestrndup(db.s, db.l, conn->persistent); conn->connect_or_select_db.l = db.l; if (!conn->connect_or_select_db.s) { /* OOM */ SET_OOM_ERROR(conn->error_info); ret = FAIL; } } DBG_RETURN(ret); }
NTSTATUS CCaptureDevice:: DispatchQueryCapabilities( _In_ PKSDEVICE Device, _In_ PIRP Irp, _Inout_ PDEVICE_CAPABILITIES Capabilities ) { PAGED_CODE(); DBG_ENTER("()"); NTSTATUS Status = Recast(Device)-> PnpQueryCapabilities( Irp, Capabilities ); DBG_LEAVE("()=0x%08X", Status); return Status; }
/* {{{ mysqlnd_net::dtor */ static void MYSQLND_METHOD(mysqlnd_net, dtor)(MYSQLND_NET * const net, MYSQLND_STATS * const stats, MYSQLND_ERROR_INFO * const error_info) { DBG_ENTER("mysqlnd_net::dtor"); if (net) { net->data->m.free_contents(net); net->data->m.close_stream(net, stats, error_info); if (net->cmd_buffer.buffer) { DBG_INF("Freeing cmd buffer"); mnd_pefree(net->cmd_buffer.buffer, net->persistent); net->cmd_buffer.buffer = NULL; } mnd_pefree(net->data, net->data->persistent); mnd_pefree(net, net->persistent); } DBG_VOID_RETURN; }
/* {{{ mysqlnd_mempool_create */ PHPAPI MYSQLND_MEMORY_POOL * mysqlnd_mempool_create(size_t arena_size) { /* We calloc, because we free(). We don't mnd_calloc() for a reason. */ MYSQLND_MEMORY_POOL * ret = mnd_ecalloc(1, sizeof(MYSQLND_MEMORY_POOL)); DBG_ENTER("mysqlnd_mempool_create"); if (ret) { ret->get_chunk = mysqlnd_mempool_get_chunk; ret->free_size = ret->arena_size = arena_size ? arena_size : 0; ret->refcount = 0; /* OOM ? */ ret->arena = mnd_emalloc(ret->arena_size); if (!ret->arena) { mysqlnd_mempool_destroy(ret); ret = NULL; } } DBG_RETURN(ret); }
/* {{{ mysqlnd_vio::dtor */ static void MYSQLND_METHOD(mysqlnd_vio, dtor)(MYSQLND_VIO * const vio, MYSQLND_STATS * const stats, MYSQLND_ERROR_INFO * const error_info) { DBG_ENTER("mysqlnd_vio::dtor"); if (vio) { vio->data->m.free_contents(vio); vio->data->m.close_stream(vio, stats, error_info); if (vio->cmd_buffer.buffer) { DBG_INF("Freeing cmd buffer"); mnd_pefree(vio->cmd_buffer.buffer, vio->persistent); vio->cmd_buffer.buffer = NULL; } mnd_pefree(vio->data, vio->data->persistent); mnd_pefree(vio, vio->persistent); } DBG_VOID_RETURN; }
/* {{{ ps_fetch_date */ static void ps_fetch_date(zval *zv, const MYSQLND_FIELD * const field, unsigned int pack_len, zend_uchar **row, zend_bool as_unicode TSRMLS_DC) { struct st_mysqlnd_time t = {0}; unsigned int length; /* First byte encodes the length*/ char * value; DBG_ENTER("ps_fetch_date"); if ((length = php_mysqlnd_net_field_length(row))) { zend_uchar *to= *row; t.time_type= MYSQLND_TIMESTAMP_DATE; t.neg= 0; t.second_part = t.hour = t.minute = t.second = 0; t.year = (unsigned int) sint2korr(to); t.month = (unsigned int) to[2]; t.day = (unsigned int) to[3]; (*row)+= length; } else { memset(&t, 0, sizeof(t)); t.time_type = MYSQLND_TIMESTAMP_DATE; } length = mnd_sprintf(&value, 0, "%04u-%02u-%02u", t.year, t.month, t.day); DBG_INF_FMT("%s", value); #if MYSQLND_UNICODE if (!as_unicode) { #endif ZVAL_STRINGL(zv, value, length, 1); mnd_sprintf_free(value); #if MYSQLND_UNICODE } else { ZVAL_UTF8_STRINGL(zv, value, length, ZSTR_AUTOFREE); } #endif DBG_VOID_RETURN; }
/* {{{ mysqlnd_com_handshake_create_command */ static struct st_mysqlnd_protocol_command * mysqlnd_com_handshake_create_command(va_list args) { struct st_mysqlnd_protocol_com_handshake_command * command; DBG_ENTER("mysqlnd_com_handshake_create_command"); command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_handshake_command)); if (command) { command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); command->context.user = *va_arg(args, const MYSQLND_CSTRING *); command->context.passwd = *va_arg(args, const MYSQLND_CSTRING *); command->context.database = *va_arg(args, const MYSQLND_CSTRING *); command->context.client_flags = va_arg(args, size_t); command->parent.free_command = mysqlnd_com_no_params_free_command; command->parent.run = mysqlnd_com_handshake_run; } DBG_RETURN((struct st_mysqlnd_protocol_command *) command); }
/* {{{ ps_fetch_float */ static void ps_fetch_float(zval * zv, const MYSQLND_FIELD * const field, unsigned int pack_len, zend_uchar ** row) { float fval; double dval; DBG_ENTER("ps_fetch_float"); float4get(fval, *row); (*row)+= 4; DBG_INF_FMT("value=%f", fval); #ifndef NOT_FIXED_DEC # define NOT_FIXED_DEC 31 #endif dval = mysql_float_to_double(fval, (field->decimals >= NOT_FIXED_DEC) ? -1 : field->decimals); ZVAL_DOUBLE(zv, dval); DBG_VOID_RETURN; }
/** * ConfigMMCRegs - Used to configure the main memory registers in the JAGCore * @pAdapter: pointer to our adapter structure */ void ConfigMMCRegs(struct et131x_adapter *pAdapter) { MMC_CTRL_t mmc_ctrl = { 0 }; DBG_ENTER(et131x_dbginfo); /* All we need to do is initialize the Memory Control Register */ mmc_ctrl.bits.force_ce = 0x0; mmc_ctrl.bits.rxdma_disable = 0x0; mmc_ctrl.bits.txdma_disable = 0x0; mmc_ctrl.bits.txmac_disable = 0x0; mmc_ctrl.bits.rxmac_disable = 0x0; mmc_ctrl.bits.arb_disable = 0x0; mmc_ctrl.bits.mmc_enable = 0x1; writel(mmc_ctrl.value, &pAdapter->CSRAddress->mmc.mmc_ctrl.value); DBG_LEAVE(et131x_dbginfo); }
static void wl_adapter_detach(struct pcmcia_device *link) { struct net_device *dev = link->priv; /*--------------------------------------------------------------------*/ DBG_FUNC("wl_adapter_detach"); DBG_ENTER(DbgInfo); DBG_PARAM(DbgInfo, "link", "0x%p", link); wl_adapter_release(link); if (dev) { unregister_wlags_sysfs(dev); unregister_netdev(dev); wl_device_dealloc(dev); } DBG_LEAVE(DbgInfo); } /* wl_adapter_detach */
/* {{{ mysqlnd_mempool_free_chunk */ static void mysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL * pool, MYSQLND_MEMORY_POOL_CHUNK * chunk) { DBG_ENTER("mysqlnd_mempool_free_chunk"); if (chunk->from_pool) { /* Try to back-off and guess if this is the last block allocated */ if (chunk->ptr == (pool->arena + (pool->arena_size - pool->free_size - chunk->size))) { /* This was the last allocation. Lucky us, we can free a bit of memory from the pool. Next time we will return from the same ptr. */ pool->free_size += chunk->size; } } else { mnd_efree(chunk->ptr); } mnd_efree(chunk); DBG_VOID_RETURN; }
void env_delete(word segm) { DBG_ENTER("env_delete", Suppl_env) DBG_ARGUMENTS( ("env=%u", segm) ) chkMem unless_segm(segm) DBG_EXIT DBG_ARGUMENTS( ("effective env=%u", segm) ) pokew(SEG2MCB(segm), MCB_OFF_OWNER, _psp); freeBlk(segm); chkMem /* Make sure the deleted segment won't be referenced */ env_relocateSegment(segm, 0); DBG_EXIT }
/******************************************************************************* * wl_process_assoc_status() ******************************************************************************* * * DESCRIPTION: * * Process the association status event signaled by the device. * * PARAMETERS: * * lp - a pointer to the device's private structure * * RETURNS: * * N/A * ******************************************************************************/ void wl_process_assoc_status( struct wl_private *lp ) { ASSOC_STATUS_STRCT *assoc_stat; /*------------------------------------------------------------------------*/ DBG_FUNC( "wl_process_assoc_status" ); DBG_ENTER( DbgInfo ); if( lp != NULL ) { assoc_stat = (ASSOC_STATUS_STRCT *)&lp->assoc_stat; wl_endian_translate_event( (ltv_t *)assoc_stat ); switch( assoc_stat->assocStatus ) { case 1: DBG_TRACE( DbgInfo, "Association Status : STA Associated\n" ); break; case 2: DBG_TRACE( DbgInfo, "Association Status : STA Reassociated\n" ); break; case 3: DBG_TRACE( DbgInfo, "Association Status : STA Disassociated\n" ); break; default: DBG_TRACE( DbgInfo, "Association Status : UNKNOWN (0x%04x)\n", assoc_stat->assocStatus ); break; } DBG_TRACE(DbgInfo, "STA Address : %pM\n", assoc_stat->staAddr); if(( assoc_stat->assocStatus == 2 ) && ( assoc_stat->len == 8 )) { DBG_TRACE(DbgInfo, "Old AP Address : %pM\n", assoc_stat->oldApAddr); } } DBG_LEAVE( DbgInfo ); return; } // wl_process_assoc_status
/* {{{ mysqlnd_command::stmt_close */ static enum_func_status MYSQLND_METHOD(mysqlnd_command, stmt_close)(MYSQLND_CONN_DATA * const conn, const zend_ulong stmt_id) { func_mysqlnd_protocol_payload_decoder_factory__send_command send_command = conn->payload_decoder_factory->m.send_command; zend_uchar cmd_buf[MYSQLND_STMT_ID_LENGTH /* statement id */]; enum_func_status ret = FAIL; DBG_ENTER("mysqlnd_command::stmt_close"); int4store(cmd_buf, stmt_id); ret = send_command(conn->payload_decoder_factory, COM_STMT_CLOSE, cmd_buf, sizeof(cmd_buf), FALSE, &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->m->send_close, conn); DBG_RETURN(ret); }
/* {{{ mysqlnd_net::network_read */ static enum_func_status MYSQLND_METHOD(mysqlnd_net, network_read)(MYSQLND * conn, zend_uchar * buffer, size_t count TSRMLS_DC) { size_t to_read = count, ret; size_t old_chunk_size = conn->net->stream->chunk_size; DBG_ENTER("mysqlnd_net::network_read"); DBG_INF_FMT("count=%u", count); conn->net->stream->chunk_size = MIN(to_read, conn->net->options.net_read_buffer_size); while (to_read) { if (!(ret = php_stream_read(conn->net->stream, (char *) buffer, to_read))) { DBG_ERR_FMT("Error while reading header from socket"); DBG_RETURN(FAIL); } buffer += ret; to_read -= ret; } MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_BYTES_RECEIVED, count); conn->net->stream->chunk_size = old_chunk_size; DBG_RETURN(PASS); }
/* {{{ mysqlnd_com_quit_run */ enum_func_status mysqlnd_com_quit_run(void *cmd) { struct st_mysqlnd_protocol_com_quit_command * command = (struct st_mysqlnd_protocol_com_quit_command *) cmd; enum_func_status ret = FAIL; MYSQLND_CONN_DATA * conn = command->context.conn; func_mysqlnd_protocol_payload_decoder_factory__send_command send_command = conn->payload_decoder_factory->m.send_command; DBG_ENTER("mysqlnd_com_quit_run"); ret = send_command(conn->payload_decoder_factory, COM_QUIT, NULL, 0, TRUE, &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->m->send_close, conn); DBG_RETURN(ret); }
INT32 CInvHead::ShowList() { DBG_ENTER("CInvHead::ShowList"); CInvDet *p = pHead; //若为空链表 if (pHead == NULL) { DBG_ASSERT_WARNING(false,("The list is empty!")); DBG_RETURN(FAILURE); } //若为非空链表 while (p) { DBG_PRINT(("m_spbm = %s,", p->m_spbm.c_str() )); p = p->pNext; } DBG_RETURN(SUCCESS); }
/* {{{ mysqlnd_mempool_resize_chunk */ static void * mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL * pool, void * ptr, size_t old_size, size_t size) { DBG_ENTER("mysqlnd_mempool_resize_chunk"); /* Try to back-off and guess if this is the last block allocated */ if (ptr == pool->last && (ZEND_MM_ALIGNED_SIZE(size) <= ((char*)pool->arena->end - (char*)ptr))) { /* This was the last allocation. Lucky us, we can free a bit of memory from the pool. Next time we will return from the same ptr. */ pool->arena->ptr = (char*)ptr + ZEND_MM_ALIGNED_SIZE(size); } else { void *new_ptr = mysqlnd_arena_alloc(&pool->arena, size); memcpy(new_ptr, ptr, MIN(old_size, size)); pool->last = ptr = new_ptr; } DBG_RETURN(ptr); }
/* {{{ mysqlnd_com_stmt_fetch_run */ static enum_func_status mysqlnd_com_stmt_fetch_run(void *cmd) { struct st_mysqlnd_protocol_com_stmt_fetch_command * command = (struct st_mysqlnd_protocol_com_stmt_fetch_command *) cmd; enum_func_status ret = FAIL; MYSQLND_CONN_DATA * conn = command->context.conn; func_mysqlnd_protocol_payload_decoder_factory__send_command send_command = conn->payload_decoder_factory->m.send_command; DBG_ENTER("mysqlnd_com_stmt_fetch_run"); ret = send_command(conn->payload_decoder_factory, COM_STMT_FETCH, (zend_uchar*) command->context.payload.s, command->context.payload.l, FALSE, &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->m->send_close, conn); DBG_RETURN(ret); }
char *StrQuote(const char * const s, const STR_QUOTES * const quotes) { char *result; char *metachars; const char *p; const char *q; int right, ch; static char buf_l[2] = " "; static char buf_r[2] = " "; DBG_ENTER("StrQuote", Suppl_dynstr) assert(quotes); DBG_ARGUMENTS( ("s=\"%s\"", s) ) if(!s) { eno_set(EINVAL); DBG_RETURN_S(0) }
/* {{{ mysqlnd_res_meta::free */ static void MYSQLND_METHOD(mysqlnd_res_meta, free)(MYSQLND_RES_METADATA * meta) { int i; MYSQLND_FIELD *fields; DBG_ENTER("mysqlnd_res_meta::free"); if ((fields = meta->fields)) { DBG_INF("Freeing fields metadata"); i = meta->field_count; while (i--) { php_mysqlnd_free_field_metadata(fields++); } meta->fields = NULL; } DBG_INF("Freeing metadata structure"); DBG_VOID_RETURN; }
/** Process the transmit completion This routine use ::EslSocketTxComplete to perform the transmit completion processing for data packets. This routine is called by the UDPv4 network layer when a data transmit request completes. @param [in] Event The normal transmit completion event @param [in] pIo Address of an ::ESL_IO_MGMT structure **/ VOID EslUdp6TxComplete ( IN EFI_EVENT Event, IN ESL_IO_MGMT * pIo ) { UINT32 LengthInBytes; ESL_PORT * pPort; ESL_PACKET * pPacket; ESL_SOCKET * pSocket; EFI_STATUS Status; DBG_ENTER ( ); // // Locate the active transmit packet // pPacket = pIo->pPacket; pPort = pIo->pPort; pSocket = pPort->pSocket; // // Get the transmit length and status // LengthInBytes = pPacket->Op.Udp6Tx.TxData.DataLength; pSocket->TxBytes -= LengthInBytes; Status = pIo->Token.Udp6Tx.Status; // // Complete the transmit operation // EslSocketTxComplete ( pIo, LengthInBytes, Status, "UDP ", &pSocket->pTxPacketListHead, &pSocket->pTxPacketListTail, &pPort->pTxActive, &pPort->pTxFree ); DBG_EXIT ( ); }
/** * et131x_stats - Return the current device statistics. * @netdev: device whose stats are being queried * * Returns 0 on success, errno on failure (as defined in errno.h) */ struct net_device_stats *et131x_stats(struct net_device *netdev) { struct et131x_adapter *adapter = netdev_priv(netdev); struct net_device_stats *stats = &adapter->net_stats; CE_STATS_t *devstat = &adapter->Stats; DBG_ENTER(et131x_dbginfo); stats->rx_packets = devstat->ipackets; stats->tx_packets = devstat->opackets; stats->rx_errors = devstat->length_err + devstat->alignment_err + devstat->crc_err + devstat->code_violations + devstat->other_errors; stats->tx_errors = devstat->max_pkt_error; stats->multicast = devstat->multircv; stats->collisions = devstat->collisions; stats->rx_length_errors = devstat->length_err; stats->rx_over_errors = devstat->rx_ov_flow; stats->rx_crc_errors = devstat->crc_err; // NOTE: These stats don't have corresponding values in CE_STATS, so we're // going to have to update these directly from within the TX/RX code //stats->rx_bytes = 20; //devstat->; //stats->tx_bytes = 20; //devstat->; //stats->rx_dropped = devstat->; //stats->tx_dropped = devstat->; // NOTE: Not used, can't find analogous statistics //stats->rx_frame_errors = devstat->; //stats->rx_fifo_errors = devstat->; //stats->rx_missed_errors = devstat->; //stats->tx_aborted_errors = devstat->; //stats->tx_carrier_errors = devstat->; //stats->tx_fifo_errors = devstat->; //stats->tx_heartbeat_errors = devstat->; //stats->tx_window_errors = devstat->; DBG_LEAVE(et131x_dbginfo); return stats; }
/** * et131x_ioctl_mii - The function which handles MII IOCTLs * @netdev: device on which the query is being made * @reqbuf: the request-specific data buffer * @cmd: the command request code * * Returns 0 on success, errno on failure (as defined in errno.h) */ int et131x_ioctl_mii(struct net_device *netdev, struct ifreq *reqbuf, int cmd) { int status = 0; struct et131x_adapter *pAdapter = netdev_priv(netdev); struct mii_ioctl_data *data = if_mii(reqbuf); DBG_ENTER(et131x_dbginfo); switch (cmd) { case SIOCGMIIPHY: DBG_VERBOSE(et131x_dbginfo, "SIOCGMIIPHY\n"); data->phy_id = pAdapter->Stats.xcvr_addr; break; case SIOCGMIIREG: DBG_VERBOSE(et131x_dbginfo, "SIOCGMIIREG\n"); if (!capable(CAP_NET_ADMIN)) { status = -EPERM; } else { status = MiRead(pAdapter, data->reg_num, &data->val_out); } break; case SIOCSMIIREG: DBG_VERBOSE(et131x_dbginfo, "SIOCSMIIREG\n"); if (!capable(CAP_NET_ADMIN)) { status = -EPERM; } else { status = MiWrite(pAdapter, data->reg_num, data->val_in); } break; default: status = -EOPNOTSUPP; } DBG_LEAVE(et131x_dbginfo); return status; }
PGPError PMAddConfig(NDIS_HANDLE handle, PGPnetKernelConfig *pConfig) { PGPnetPMContext *pContext = (PGPnetPMContext*) handle; NDIS_STATUS status; DBG_FUNC("PMAddConfig") DBG_ENTER(); /* if config doesn't exist, create memory for it */ if (!pContext->pConfig) { #ifndef USERLAND_TEST status = NdisAllocateMemory(&(pContext->pConfig), sizeof(PGPnetKernelConfig), 0, HighestAcceptableAddress); if (status != NDIS_STATUS_SUCCESS) return kPGPError_OutOfMemory; #else pContext->pConfig = malloc(sizeof(PGPnetKernelConfig)); if (!pContext->pConfig) return kPGPError_OutOfMemory; #endif /* USERLAND_TEST */ } /* clear out anything there */ pgpClearMemory(pContext->pConfig, sizeof(PGPnetKernelConfig)); /* copy configuration values */ pContext->pConfig->bPGPnetEnabled = pConfig->bPGPnetEnabled; pContext->pConfig->bAllowUnconfigHost = pConfig->bAllowUnconfigHost; pContext->pConfig->bAttemptUnconfigHost = pConfig->bAttemptUnconfigHost; DBG_LEAVE(kPGPError_NoErr); return kPGPError_NoErr; }
/* {{{ mysqlnd_native_auth_get_auth_data */ static void mysqlnd_caching_sha2_handle_server_response(struct st_mysqlnd_authentication_plugin *self, MYSQLND_CONN_DATA * conn, const zend_uchar * auth_plugin_data, const size_t auth_plugin_data_len, const char * const passwd, const size_t passwd_len) { DBG_ENTER("mysqlnd_caching_sha2_handle_server_response"); MYSQLND_PACKET_CACHED_SHA2_RESULT result_packet; conn->payload_decoder_factory->m.init_cached_sha2_result_packet(&result_packet); if (FAIL == PACKET_READ(conn, &result_packet)) { DBG_VOID_RETURN; } switch (result_packet.response_code) { case 3: DBG_INF("fast path succeeded"); DBG_VOID_RETURN; case 4: if (conn->vio->data->ssl || conn->unix_socket.s) { DBG_INF("fast path failed, doing full auth via SSL"); result_packet.password = (zend_uchar *)passwd; result_packet.password_len = passwd_len + 1; PACKET_WRITE(conn, &result_packet); } else { DBG_INF("fast path failed, doing full auth without SSL"); result_packet.password_len = mysqlnd_caching_sha2_get_and_use_key(conn, auth_plugin_data, auth_plugin_data_len, &result_packet.password, passwd, passwd_len); PACKET_WRITE(conn, &result_packet); efree(result_packet.password); } DBG_VOID_RETURN; case 2: // The server tried to send a key, which we didn't expect // fall-through default: php_error_docref(NULL, E_WARNING, "Unexpected server response while doing caching_sha2 auth: %i", result_packet.response_code); } DBG_VOID_RETURN; }
/* {{{ mysqlnd_switch_to_ssl_if_needed */ static enum_func_status mysqlnd_switch_to_ssl_if_needed(MYSQLND_CONN_DATA * conn, unsigned int charset_no, size_t server_capabilities, const MYSQLND_SESSION_OPTIONS * const session_options, zend_ulong mysql_flags) { enum_func_status ret = FAIL; const MYSQLND_CHARSET * charset; DBG_ENTER("mysqlnd_switch_to_ssl_if_needed"); if (session_options->charset_name && (charset = mysqlnd_find_charset_name(session_options->charset_name))) { charset_no = charset->nr; } { size_t client_capabilities = mysql_flags; ret = conn->run_command(COM_ENABLE_SSL, conn, client_capabilities, server_capabilities, charset_no); } DBG_RETURN(ret); }
/* {{{ mysqlnd_vio::get_open_stream */ static func_mysqlnd_vio__open_stream MYSQLND_METHOD(mysqlnd_vio, get_open_stream)(MYSQLND_VIO * const vio, const MYSQLND_CSTRING scheme, MYSQLND_ERROR_INFO * const error_info) { func_mysqlnd_vio__open_stream ret = NULL; DBG_ENTER("mysqlnd_vio::get_open_stream"); if (scheme.l > (sizeof("pipe://") - 1) && !memcmp(scheme.s, "pipe://", sizeof("pipe://") - 1)) { ret = vio->data->m.open_pipe; } else if ((scheme.l > (sizeof("tcp://") - 1) && !memcmp(scheme.s, "tcp://", sizeof("tcp://") - 1)) || (scheme.l > (sizeof("unix://") - 1) && !memcmp(scheme.s, "unix://", sizeof("unix://") - 1))) { ret = vio->data->m.open_tcp_or_unix; } if (!ret) { SET_CLIENT_ERROR(error_info, CR_CONNECTION_ERROR, UNKNOWN_SQLSTATE, "No handler for this scheme"); } DBG_RETURN(ret); }
//------------------------------------------------- //删除链表,释放链表空间 //------------------------------------------------- INT32 CInvHead::DelList() { DBG_PRINT(("进入DelList函数")); DBG_ENTER("CInvHead::DelList"); CInvDet *p = pHead; CInvDet *s; while (p) { DBG_PRINT(("delete CInvDet: DP_NO = %s!", p->m_spbm.c_str())); s = p; p = p->pNext; //delete s; s->FreeInvDet();//释放该节点所占空间 } pHead = NULL; pEnd = NULL; DBG_PRINT(("退出DelList函数")); DBG_RETURN(SUCCESS); }