int ping_ultrasonic(int echo, int trig, int max_distance) //max_distance in cm {//ping HC-SR04 ultrasonic range finder, 10us trigger pulse, sends eight 40kHz pulses //int start_time; int max_time; //max_time in system cycles int flight_time; //char message[100]; //sprintf(message, "bump"); //NU32_WriteUART1(message); max_time = max_distance * 2320; //Distance(cm) = Time(us)/58, 40 core cycles per us, 58*40=2320 //start_time = ReadCoreTimer(); WriteCoreTimer(0); set_pin(trig, HIGH); while(ReadCoreTimer() < 1600){ //400 cycles at 40MHz, 10us trigger pulse } set_pin(trig, LOW); //NU32_WriteUART1(message); while(!get_pin(echo)){ } //NU32_WriteUART1(message); //start_time = ReadCoreTimer(); WriteCoreTimer(0); while(get_pin(echo) && (ReadCoreTimer() < max_time)){ } //flight_time = ReadCoreTimer() - start_time; flight_time = ReadCoreTimer(); //sprintf(message, "%d\n", flight_time); //NU32_WriteUART1(message); return flight_time / 2320; }
/** Randomly place pairs of cards on the board */ void deal_cards() { // clear the board for (uint8_t i = 0; i < CARD_COUNT; ++i) { board[i] = (tile_t) { .color = 0, .state = GONE }; } const uint8_t dealt_cards = get_pin(FLAG_SMALL) ? CARD_COUNT : CARD_COUNT_SMALL; // for all pair_COUNT for (uint8_t i = 0; i < (dealt_cards / 2); ++i) { // for both cards in pair for (uint8_t j = 0; j < 2; j++) { // loop until empty slot is found while(1) { const uint8_t pos = rand() % dealt_cards; if (board[pos].state == GONE) { board[pos] = (tile_t) { .color = i, .state = SECRET }; break; } } } } }
rt_err_t es32f0_pin_detach_irq(struct rt_device *device, rt_int32_t pin) { const struct pin_index *index; rt_base_t level; rt_int32_t irqindex = -1; index = get_pin(pin); if (index == RT_NULL) { return RT_ENOSYS; } irqindex = index->pin & 0x00FF; if (irqindex < 0 || irqindex >= ITEM_NUM(pin_irq_map)) { return RT_ENOSYS; } level = rt_hw_interrupt_disable(); if (pin_irq_hdr_tab[irqindex].pin == -1) { rt_hw_interrupt_enable(level); return RT_EOK; } pin_irq_hdr_tab[irqindex].pin = -1; pin_irq_hdr_tab[irqindex].hdr = RT_NULL; pin_irq_hdr_tab[irqindex].mode = 0; pin_irq_hdr_tab[irqindex].args = RT_NULL; rt_hw_interrupt_enable(level); return RT_EOK; }
void pinMode(uint8_t pin, uint8_t mode) { const struct pin_index *index; GPIO_InitTypeDef GPIO_InitStructure; index = get_pin(pin); if(index == RT_NULL) { return; } /* GPIO Periph clock enable */ RCC_AHB1PeriphClockCmd(index->rcc, ENABLE); /* Configure GPIO_InitStructure */ GPIO_InitStructure.GPIO_Pin = index->pin; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; if(mode == OUTPUT) { /* output setting */ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; } else { /* input setting */ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; } GPIO_Init(index->gpio, &GPIO_InitStructure); }
rt_err_t gd32_pin_detach_irq(struct rt_device *device, rt_int32_t pin) { const struct pin_index *index; rt_base_t level; rt_int32_t hdr_index = -1; index = get_pin(pin); if (index == RT_NULL) { return RT_EINVAL; } hdr_index = bit2bitno(index->pin); if (hdr_index < 0 || hdr_index >= ITEM_NUM(pin_irq_map)) { return RT_EINVAL; } level = rt_hw_interrupt_disable(); if (pin_irq_hdr_tab[hdr_index].pin == -1) { rt_hw_interrupt_enable(level); return RT_EOK; } pin_irq_hdr_tab[hdr_index].pin = -1; pin_irq_hdr_tab[hdr_index].hdr = RT_NULL; pin_irq_hdr_tab[hdr_index].mode = 0; pin_irq_hdr_tab[hdr_index].args = RT_NULL; rt_hw_interrupt_enable(level); return RT_EOK; }
void es32f0_pin_write(rt_device_t dev, rt_base_t pin, rt_base_t value) { const struct pin_index *index; index = get_pin(pin); if (index == RT_NULL) { return; } gpio_write_pin(index->gpio, index->pin, value); }
inline void stm32_pin_write_early(rt_base_t pin, rt_base_t value) { const struct pin_index *index; index = get_pin(pin); if (index == RT_NULL) { return; } HAL_GPIO_WritePin(index->gpio, index->pin, value); }
void stm32_pin_mode(rt_device_t dev, rt_base_t pin, rt_base_t mode) { const struct pin_index *index; GPIO_InitTypeDef GPIO_InitStruct; index = get_pin(pin); if (index == RT_NULL) { return; } /* GPIO Periph clock enable */ index->rcc(); /* Configure GPIO_InitStructure */ GPIO_InitStruct.Pin = index->pin; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; if (mode == PIN_MODE_OUTPUT) { /* output setting */ GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; } else if (mode == PIN_MODE_INPUT) { /* input setting: not pull. */ GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; } else if (mode == PIN_MODE_INPUT_PULLUP) { /* input setting: pull up. */ GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_PULLUP; } else if (mode == PIN_MODE_INPUT_PULLDOWN) { /* input setting: pull down. */ GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_PULLDOWN; } else if (mode == PIN_MODE_OUTPUT_OD) { /* output setting: od. */ GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD; GPIO_InitStruct.Pull = GPIO_NOPULL; } HAL_GPIO_Init(index->gpio, &GPIO_InitStruct); }
void stm32_pin_write(rt_device_t dev, rt_base_t pin, rt_base_t value) { const struct pin_index *index; index = get_pin(pin); if (index == RT_NULL) { return; } HAL_GPIO_WritePin(index->gpio, index->pin, (GPIO_PinState)value); }
void gd32_pin_write(rt_device_t dev, rt_base_t pin, rt_base_t value) { const struct pin_index *index; index = get_pin(pin); if (index == RT_NULL) { return; } gpio_bit_write(index->gpio_periph, index->pin, (bit_status)value); }
/** Read a byte */ uint8_t _lcd_read_byte() { _lcd_mode_r(); uint8_t res = 0; _lcd_clk(); res = (get_pin(LCD_D7) << 7) | (get_pin(LCD_D6) << 6) | (get_pin(LCD_D5) << 5) | (get_pin(LCD_D4) << 4); _lcd_clk(); res |= (get_pin(LCD_D7) << 3) | (get_pin(LCD_D6) << 2) | (get_pin(LCD_D5) << 1) | (get_pin(LCD_D4) << 0); return res; }
int es32f0_pin_read(rt_device_t dev, rt_base_t pin) { int value; const struct pin_index *index; value = PIN_LOW; index = get_pin(pin); if (index == RT_NULL) { return value; } value = gpio_read_pin(index->gpio, index->pin); return value; }
void es32f0_pin_mode(rt_device_t dev, rt_base_t pin, rt_base_t mode) { const struct pin_index *index; gpio_init_t gpio_initstruct; index = get_pin(pin); if (index == RT_NULL) { return; } /* Configure GPIO_InitStructure */ gpio_initstruct.mode = GPIO_MODE_OUTPUT; gpio_initstruct.func = GPIO_FUNC_1; gpio_initstruct.odrv = GPIO_OUT_DRIVE_NORMAL; gpio_initstruct.type = GPIO_TYPE_CMOS; gpio_initstruct.pupd = GPIO_FLOATING; gpio_initstruct.odos = GPIO_PUSH_PULL; if (mode == PIN_MODE_OUTPUT) { /* output setting */ gpio_initstruct.mode = GPIO_MODE_OUTPUT; gpio_initstruct.pupd = GPIO_FLOATING; } else if (mode == PIN_MODE_INPUT) { /* input setting: not pull. */ gpio_initstruct.mode = GPIO_MODE_INPUT; gpio_initstruct.pupd = GPIO_FLOATING; } else if (mode == PIN_MODE_INPUT_PULLUP) { /* input setting: pull up. */ gpio_initstruct.mode = GPIO_MODE_INPUT; gpio_initstruct.pupd = GPIO_PUSH_UP; } else if (mode == PIN_MODE_INPUT_PULLDOWN) { /* input setting: pull down. */ gpio_initstruct.mode = GPIO_MODE_INPUT; gpio_initstruct.pupd = GPIO_PUSH_DOWN; } else if (mode == PIN_MODE_OUTPUT_OD) { /* output setting: od. */ gpio_initstruct.mode = GPIO_MODE_OUTPUT; gpio_initstruct.pupd = GPIO_FLOATING; gpio_initstruct.odos = GPIO_OPEN_DRAIN; } gpio_init(index->gpio, index->pin, &gpio_initstruct); }
/* * Log-into the token if necesary. * * @slot is PKCS11 slot to log in * @tok is PKCS11 token to log in (??? could be derived as @slot->token) * @ui_method is OpenSSL user inteface which is used to ask for a password * @callback_data are application data to the user interface * @return 1 on success, 0 on error. */ static int pkcs11_login(ENGINE_CTX *ctx, PKCS11_SLOT *slot, PKCS11_TOKEN *tok, UI_METHOD *ui_method, void *callback_data) { if (tok->loginRequired) { /* If the token has a secure login (i.e., an external keypad), * then use a NULL pin. Otherwise, check if a PIN exists. If * not, allocate and obtain a new PIN. */ if (tok->secureLogin) { /* Free the PIN if it has already been * assigned (i.e, cached by get_pin) */ destroy_pin(ctx); } else if (ctx->pin == NULL) { ctx->pin = OPENSSL_malloc(MAX_PIN_LENGTH * sizeof(char)); ctx->pin_length = MAX_PIN_LENGTH; if (ctx->pin == NULL) { fprintf(stderr, "Could not allocate memory for PIN"); return 0; } memset(ctx->pin, 0, MAX_PIN_LENGTH * sizeof(char)); if (!get_pin(ctx, ui_method, callback_data)) { destroy_pin(ctx); fprintf(stderr, "No pin code was entered"); return 0; } } /* Now login in with the (possibly NULL) pin */ if (PKCS11_login(slot, 0, ctx->pin)) { /* Login failed, so free the PIN if present */ destroy_pin(ctx); fprintf(stderr, "Login failed\n"); return 0; } /* Login successful, PIN retained in case further logins are * required. This will occur on subsequent calls to the * pkcs11_load_key function. Subsequent login calls should be * relatively fast (the token should maintain its own login * state), although there may still be a slight performance * penalty. We could maintain state noting that successful * login has been performed, but this state may not be updated * if the token is removed and reinserted between calls. It * seems safer to retain the PIN and perform a login on each * call to pkcs11_load_key, even if this may not be strictly * necessary. */ /* TODO confirm that multiple login attempts do not introduce * significant performance penalties */ } return 1; }
void gd32_pin_mode(rt_device_t dev, rt_base_t pin, rt_base_t mode) { const struct pin_index *index; rt_uint32_t pin_mode; rt_uint32_t otype; rt_uint32_t pull_up_down; index = get_pin(pin); if (index == RT_NULL) { return; } /* GPIO Periph clock enable */ rcu_periph_clock_enable(index->clk); pin_mode = GPIO_MODE_OUTPUT; otype = GPIO_OTYPE_PP; pull_up_down = GPIO_PUPD_NONE; switch(mode) { case PIN_MODE_OUTPUT: /* output setting */ break; case PIN_MODE_OUTPUT_OD: /* output setting: od. */ otype = GPIO_OTYPE_OD; break; case PIN_MODE_INPUT: /* input setting: not pull. */ pin_mode = GPIO_MODE_INPUT; break; case PIN_MODE_INPUT_PULLUP: /* input setting: pull up. */ pin_mode = GPIO_MODE_INPUT; pull_up_down = GPIO_PUPD_PULLUP; break; case PIN_MODE_INPUT_PULLDOWN: /* input setting: pull down. */ pin_mode = GPIO_MODE_INPUT; pull_up_down = GPIO_PUPD_PULLDOWN; break; default: break; } gpio_mode_set(index->gpio_periph, pin_mode, pull_up_down, index->pin); gpio_output_options_set(index->gpio_periph, otype, GPIO_OSPEED_50MHZ, index->pin); }
inline int stm32_pin_read_early(rt_base_t pin) { int value; const struct pin_index *index; value = PIN_LOW; index = get_pin(pin); if (index == RT_NULL) { return value; } value = HAL_GPIO_ReadPin(index->gpio, index->pin); return value; }
void gpio_config(pin_t pin, pin_dir_t dir) { //Clock the port RCC_AHB1PeriphClockCmd(1 << get_port(pin), ENABLE); GPIO_InitTypeDef def; def.GPIO_Pin = 1 << get_pin(pin); def.GPIO_Mode = dir; def.GPIO_Speed = GPIO_Speed_50MHz; if (dir) def.GPIO_OType = GPIO_OType_PP; //output : Push Pull else def.GPIO_OType = GPIO_OType_OD; //input : Open Drain def.GPIO_PuPd = GPIO_PuPd_UP; //Pull up resistor GPIO_Init(ports[get_port(pin)], &def); }
int gd32_pin_read(rt_device_t dev, rt_base_t pin) { int value; const struct pin_index *index; value = PIN_LOW; index = get_pin(pin); if (index == RT_NULL) { return value; } value = gpio_input_bit_get(index->gpio_periph, index->pin); return value; }
void stm32_pin_mode(rt_device_t dev, rt_base_t pin, rt_base_t mode) { const struct pin_index *index; GPIO_InitTypeDef GPIO_InitStructure; index = get_pin(pin); if (index == RT_NULL) { return; } /* GPIO Periph clock enable */ RCC_AHB1PeriphClockCmd(index->rcc, ENABLE); /* Configure GPIO_InitStructure */ GPIO_InitStructure.GPIO_Pin = index->pin; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz; if (mode == PIN_MODE_OUTPUT) { /* output setting */ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; } else if (mode == PIN_MODE_INPUT) { /* input setting: not pull. */ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; } else if (mode == PIN_MODE_INPUT_PULLUP) { /* input setting: pull up. */ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; } else { /* input setting:default. */ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; } GPIO_Init(index->gpio, &GPIO_InitStructure); }
rt_err_t es32f0_pin_attach_irq(struct rt_device *device, rt_int32_t pin, rt_uint32_t mode, void (*hdr)(void *args), void *args) { const struct pin_index *index; rt_base_t level; rt_int32_t irqindex; index = get_pin(pin); if (index == RT_NULL) { return RT_ENOSYS; } /**pin no. convert to dec no.**/ for (irqindex = 0; irqindex < 16; irqindex++) { if ((0x01 << irqindex) == index->pin) { break; } } if (irqindex < 0 || irqindex >= ITEM_NUM(pin_irq_map)) { return RT_ENOSYS; } level = rt_hw_interrupt_disable(); if (pin_irq_hdr_tab[irqindex].pin == pin && pin_irq_hdr_tab[irqindex].hdr == hdr && pin_irq_hdr_tab[irqindex].mode == mode && pin_irq_hdr_tab[irqindex].args == args) { rt_hw_interrupt_enable(level); return RT_EOK; } if (pin_irq_hdr_tab[irqindex].pin != -1) { rt_hw_interrupt_enable(level); return RT_EBUSY; } pin_irq_hdr_tab[irqindex].pin = pin; pin_irq_hdr_tab[irqindex].hdr = hdr; pin_irq_hdr_tab[irqindex].mode = mode; pin_irq_hdr_tab[irqindex].args = args; rt_hw_interrupt_enable(level); return RT_EOK; }
void digitalWrite(uint8_t pin, uint8_t value) { const struct pin_index *index; index = get_pin(pin); if(index == RT_NULL) { return; } if(value == LOW) { GPIO_ResetBits(index->gpio, index->pin); } else { GPIO_SetBits(index->gpio, index->pin); } }
void stm32_pin_write(rt_device_t dev, rt_base_t pin, rt_base_t value) { const struct pin_index *index; index = get_pin(pin); if (index == RT_NULL) { return; } if (value == PIN_LOW) { GPIO_ResetBits(index->gpio, index->pin); } else { GPIO_SetBits(index->gpio, index->pin); } }
rt_err_t gd32_pin_attach_irq(struct rt_device *device, rt_int32_t pin, rt_uint32_t mode, void (*hdr)(void *args), void *args) { const struct pin_index *index; rt_base_t level; rt_int32_t hdr_index = -1; index = get_pin(pin); if (index == RT_NULL) { return RT_EINVAL; } hdr_index = bit2bitno(index->pin); if (hdr_index < 0 || hdr_index >= ITEM_NUM(pin_irq_map)) { return RT_EINVAL; } level = rt_hw_interrupt_disable(); if (pin_irq_hdr_tab[hdr_index].pin == pin && pin_irq_hdr_tab[hdr_index].hdr == hdr && pin_irq_hdr_tab[hdr_index].mode == mode && pin_irq_hdr_tab[hdr_index].args == args) { rt_hw_interrupt_enable(level); return RT_EOK; } if (pin_irq_hdr_tab[hdr_index].pin != -1) { rt_hw_interrupt_enable(level); return RT_EFULL; } pin_irq_hdr_tab[hdr_index].pin = pin; pin_irq_hdr_tab[hdr_index].hdr = hdr; pin_irq_hdr_tab[hdr_index].mode = mode; pin_irq_hdr_tab[hdr_index].args = args; rt_hw_interrupt_enable(level); return RT_EOK; }
void stm32_pin_mode_early(rt_base_t pin, rt_base_t mode) { const struct pin_index *index; GPIO_InitTypeDef GPIO_InitStructure; index = get_pin(pin); if (index == RT_NULL) { return; } /* Configure GPIO_InitStructure */ GPIO_InitStructure.Pin = index->pin; GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_VERY_HIGH; __RCC_GPIO_CLK_ENABLE(index->clk); if (mode == GPIO_MODE_OUTPUT_PP) { /* output setting */ GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStructure.Pull = GPIO_NOPULL; } else if(mode == GPIO_MODE_OUTPUT_OD) { GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_OD; GPIO_InitStructure.Pull = GPIO_NOPULL; } else if (mode == GPIO_MODE_INPUT) { /* input setting: not pull. */ GPIO_InitStructure.Mode = GPIO_MODE_INPUT; GPIO_InitStructure.Pull = GPIO_PULLUP; } else if(((mode & 0xFF) == GPIO_MODE_AF_PP) || ((mode & 0xFF) == GPIO_MODE_AF_OD) ) { GPIO_InitStructure.Mode = (mode & ~0xFF00); GPIO_InitStructure.Pull = GPIO_NOPULL; GPIO_InitStructure.Alternate = (mode & 0xFF00) >> 8; } else if(mode == GPIO_MODE_ANALOG){
/** * @brief Send verify command to verify CHV1 * @param Remaining retry count, valid values are between 3~1 * @return Unlock SIM card success or not * @retval 0 Unlock success * @retval -1 Unlock failed */ int unlock_sim(uint32_t u32RetryCnt) { while(u32RetryCnt > 0) { get_pin(); // Ask user input PIN if(SCLIB_StartTransmission(0, au8VerifyChv, 13, buf, &len) != SCLIB_SUCCESS) { sysprintf("Command Verify CHV failed\n"); break; } if(buf[0] == 0x90 || buf[1] == 0x00) { sysprintf("Pass\n"); return 0; } else { u32RetryCnt--; sysprintf("Failed, remaining retry count: %d\n", u32RetryCnt); } } sysprintf("Oops, SIM card locked\n"); return -1; }
int stm32_pin_read(rt_device_t dev, rt_base_t pin) { int value; const struct pin_index *index; value = PIN_LOW; index = get_pin(pin); if (index == RT_NULL) { return value; } if (GPIO_ReadInputDataBit(index->gpio, index->pin) == Bit_RESET) { value = PIN_LOW; } else { value = PIN_HIGH; } return value; }
int digitalRead(uint8_t pin) { int value; const struct pin_index *index; value = LOW; index = get_pin(pin); if(index == RT_NULL) { return value; } if(GPIO_ReadInputDataBit(index->gpio, index->pin) == Bit_RESET) { value = LOW; } else { value = HIGH; } return value; }
int reaver_main(int argc, char **argv) { int ret_val = EXIT_FAILURE, r = 0; time_t start_time = 0, end_time = 0; struct wps_data *wps = NULL; globule_init(); init_default_settings(); fprintf(stderr, "\nReaver v%s WiFi Protected Setup Attack Tool\n", get_version()); fprintf(stderr, "Copyright (c) 2011, Tactical Network Solutions, Craig Heffner <*****@*****.**>\n\n"); if(argc < 2) { ret_val = reaver_usage(argv[0]); goto end; } /* Process the command line arguments */ if(process_arguments(argc, argv) == EXIT_FAILURE) { ret_val = reaver_usage(argv[0]); goto end; } /* Double check reaver_usage */ if(!get_iface() || (memcmp(get_bssid(), NULL_MAC, MAC_ADDR_LEN) == 0)) { reaver_usage(argv[0]); goto end; } /* If no MAC address was provided, get it ourselves */ if(memcmp(get_mac(), NULL_MAC, MAC_ADDR_LEN) == 0) { if(!read_iface_mac()) { fprintf(stderr, "[-] Failed to retrieve a MAC address for interface '%s'!\n", get_iface()); goto end; } } /* Sanity checking on the message timeout value */ if(get_m57_timeout() > M57_MAX_TIMEOUT) { set_m57_timeout(M57_MAX_TIMEOUT); } else if(get_m57_timeout() <= 0) { set_m57_timeout(M57_DEFAULT_TIMEOUT); } /* Sanity checking on the receive timeout value */ if(get_rx_timeout() <= 0) { set_rx_timeout(DEFAULT_TIMEOUT); } /* Initialize signal handlers */ sigint_init(); sigalrm_init(); /* Mark the start time */ start_time = time(NULL); /* Do it. */ crack(); /* Mark the end time */ end_time = time(NULL); /* Check our key status */ if(get_key_status() == KEY_DONE) { wps = get_wps(); cprintf(VERBOSE, "[+] Pin cracked in %d seconds\n", (int) (end_time - start_time)); cprintf(CRITICAL, "[+] WPS PIN: '%s'\n", get_pin()); if(wps->key) cprintf(CRITICAL, "[+] WPA PSK: '%s'\n", wps->key); if(wps->essid) cprintf(CRITICAL, "[+] AP SSID: '%s'\n", wps->essid); /* Run user-supplied command */ if(get_exec_string()) { r = system(get_exec_string()); } ret_val = EXIT_SUCCESS; } else { cprintf(CRITICAL, "[-] Failed to recover WPA key\n"); } save_session(); end: globule_deinit(); return ret_val; }
bool AVTDShowGraph::buildCaptureGraph(IBaseFilter * pSrcFilter, int theIndex) { HRESULT hr = CoCreateInstance (CLSID_CaptureGraphBuilder2 , NULL, CLSCTX_INPROC, IID_ICaptureGraphBuilder2, (void **) &m_pCaptureGraphBuilder2); if (FAILED(hr)) { checkForDShowError(hr, "CoCreateInstance(m_pCaptureGraphBuilder2) failed", PLUS_FILE_LINE); return false; } // Attach the filter graph to the capture graph hr = m_pCaptureGraphBuilder2->SetFiltergraph(m_pGraphBuilder); if (FAILED(hr)) { checkForDShowError(hr, "SetFiltergraph(m_pGraphBuilder) failed", PLUS_FILE_LINE); return false; } if (pSrcFilter == 0) { // Use the system device enumerator and class enumerator to find // a video capture/preview device, such as a desktop USB video camera. hr = findCaptureDevice(&pSrcFilter, theIndex); if (FAILED(hr)) { checkForDShowError(hr, "findCaptureDevice failed", PLUS_FILE_LINE); return false; } } m_pSrcFilter = pSrcFilter; setCameraParams(_myAVTCameraIndex); // Add Capture filter to our graph. hr = m_pGraphBuilder->AddFilter(pSrcFilter, L"Video Capture"); if (FAILED(hr)) { checkForDShowError(hr, "AddFilter(\"Video Capture\") failed", PLUS_FILE_LINE); return false; } setAnalogVideoFormat(); addExtraFilters(); hr = selectVideoFormat(); if (FAILED(hr)) { checkForDShowError(hr, "selectVideoFormat() failed", PLUS_FILE_LINE); //return false; // unable to build graph } // Connect the extra filters into the graph IPin * pOut = get_pin( m_pSrcFilter, PINDIR_OUTPUT ); IPin * pIn = get_pin( m_pGrabFilter, PINDIR_INPUT); hr = m_pGraphBuilder->Connect(pOut, pIn); SafeRelease(pOut); SafeRelease(pIn); if (FAILED(hr)) { checkForDShowError(hr, "m_pGraphBuilder->Connect() failed", PLUS_FILE_LINE); return false; } pOut = get_pin(m_pGrabFilter, PINDIR_OUTPUT); hr = m_pGraphBuilder->Render( pOut ); SafeRelease(pOut); if (FAILED(hr)) { checkForDShowError(hr, "m_pGraphBuilder->Render() failed", PLUS_FILE_LINE); } return true; }
void PinTimer::onFired(void) { digitalWrite(get_pin(),digitalRead(get_pin())^HIGH); disable(); }