github/proxmark3
1
0
Fork 0
mirror of https://github.com/Proxmark/proxmark3.git synced 2025-08-19 04:49:38 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

(dirty) fix for linux to clean up the /dev/ttyACM* quicker

Browse source
This commit is contained in:
roel@libnfc.org 2013-03-21 10:59:56 +00:00
commit 13dbdd6bb1
4 changed files with 74 additions and 192 deletions
Download patch file Download diff file Expand all files Collapse all files

6
client/flasher.c
View file

@ -15,6 +15,10 @@
#include "uart.h" #include "uart.h"
#include "usb_cmd.h" #include "usb_cmd.h"
#ifdef _WIN32
# define unlink(x)
#endif
static serial_port sp; static serial_port sp;
static char* serial_port_name; static char* serial_port_name;
@ -62,6 +66,8 @@ void ReceiveCommand(UsbCommand* rxcmd) {
void CloseProxmark() { void CloseProxmark() {
// Clean up the port // Clean up the port
uart_close(sp); uart_close(sp);
// Fix for linux, it seems that it is extremely slow to release the serial port file descriptor /dev/*
unlink(serial_port_name);
} }
int OpenProxmark(size_t i) { int OpenProxmark(size_t i) {

39
client/messages.h
View file

@ -1,39 +0,0 @@
/**
* Proxmark3 (debug) messages
*
* Copyright (c) 2012, Roel Verdult
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by the
* Free Software Foundation, either version 3 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
*
*
* @file messages.h
* @brief
*/
#ifndef _PROXMARK_MESSAGES_H_
#define _PROXMARK_MESSAGES_H_
// Useful macros
#ifdef DEBUG
// #define DBG(x, args...) printf("DBG %s:%d: " x "\n", __FILE__, __LINE__,## args )
#define DBG(x, ...) fprintf(stderr, "DBG %s:%d: " x "\n", __FILE__, __LINE__, ## __VA_ARGS__ )
#else
#define DBG(...) {}
#endif
#define INFO(x, ...) printf("INFO: " x "\n", ## __VA_ARGS__ )
#define WARN(x, ...) printf("WARNING: " x "\n", ## __VA_ARGS__ )
#define ERR(x, ...) fprintf(stderr, "ERROR: " x "\n", ## __VA_ARGS__ )
#endif // _PROXMARK_MESSAGES_H_

210
client/uart.c
View file

@ -1,7 +1,7 @@
/* /*
* Proxmark3 generic uart / rs232/ serial port library * Generic uart / rs232/ serial port library
* *
* Copyright (c) 2012, Roel Verdult * Copyright (c) 2013, Roel Verdult
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@ -29,13 +29,9 @@
* @file uart.c * @file uart.c
* @brief * @brief
* *
* Partly based on uart-code written by Teunis van Beelen, available:
* http://www.teuniz.net/RS-232/index.html
*
*/ */
#include "uart.h" #include "uart.h"
#include "messages.h"
// Test if we are dealing with unix operating systems // Test if we are dealing with unix operating systems
#ifndef _WIN32 #ifndef _WIN32
@ -49,208 +45,153 @@ typedef struct {
} serial_port_unix; } serial_port_unix;
// Set time-out on 30 miliseconds // Set time-out on 30 miliseconds
const struct timeval timeout = { const struct timeval timeout = {
.tv_sec = 0, // 0 second .tv_sec = 0, // 0 second
.tv_usec = 30000 // 30000 micro seconds .tv_usec = 30000 // 30000 micro seconds
}; };
// Work-around to claim uart interface using the c_iflag (software input processing) from the termios struct // Work-around to claim uart interface using the c_iflag (software input processing) from the termios struct
#define CCLAIMED 0x80000000 #define CCLAIMED 0x00008000
char pcPort[255];
serial_port uart_open(const char* pcPortName) serial_port uart_open(const char* pcPortName)
{ {
serial_port_unix* sp = malloc(sizeof(serial_port_unix)); serial_port_unix* sp = malloc(sizeof(serial_port_unix));
strcpy(pcPort,pcPortName);
if (sp == 0) return INVALID_SERIAL_PORT; if (sp == 0) return INVALID_SERIAL_PORT;
sp->fd = open(pcPortName, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK); sp->fd = open(pcPortName, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK);
if(sp->fd == -1) if(sp->fd == -1)
{ {
uart_close(sp); uart_close(sp);
return INVALID_SERIAL_PORT; return INVALID_SERIAL_PORT;
} }
if(tcgetattr(sp->fd,&sp->tiOld) == -1) if(tcgetattr(sp->fd,&sp->tiOld) == -1)
{ {
uart_close(sp); uart_close(sp);
return INVALID_SERIAL_PORT; return INVALID_SERIAL_PORT;
} }
// Make sure the port is not claimed already // Make sure the port is not claimed already
if (sp->tiOld.c_iflag & CCLAIMED) if (sp->tiOld.c_iflag & CCLAIMED)
{ {
uart_close(sp); uart_close(sp);
return CLAIMED_SERIAL_PORT; return CLAIMED_SERIAL_PORT;
} }
// Copy the old terminal info struct // Copy the old terminal info struct
sp->tiNew = sp->tiOld; sp->tiNew = sp->tiOld;
sp->tiNew.c_cflag = CS8 | CLOCAL | CREAD; sp->tiNew.c_cflag = CS8 | CLOCAL | CREAD;
sp->tiNew.c_iflag = CCLAIMED | IGNPAR; sp->tiNew.c_iflag = CCLAIMED | IGNPAR;
sp->tiNew.c_oflag = 0; sp->tiNew.c_oflag = 0;
sp->tiNew.c_lflag = 0; sp->tiNew.c_lflag = 0;
// Set serial port equivalent to raw mode // Set serial port equivalent to raw mode
// sp->tiNew.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON); // sp->tiNew.c_iflag &= ~(CCLAIMED | IGNBRK | BRKINT | IGNPAR | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
// sp->tiNew.c_oflag &= ~OPOST; // sp->tiNew.c_oflag &= ~OPOST;
// sp->tiNew.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN); // sp->tiNew.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
// sp->tiNew.c_cflag &= ~(CSIZE | PARENB); // sp->tiNew.c_cflag &= ~(CSIZE | PARENB | CS8 | CLOCAL | CREAD);
// sp->tiNew.c_iflag |= CCLAIMED | IGNPAR;
// sp->tiNew.c_cflag |= CS8 | CLOCAL | CREAD;
sp->tiNew.c_cc[VMIN] = 0; // block until n bytes are received sp->tiNew.c_cc[VMIN] = 0; // block until n bytes are received
sp->tiNew.c_cc[VTIME] = 0; // block until a timer expires (n * 100 mSec.) sp->tiNew.c_cc[VTIME] = 0; // block until a timer expires (n * 100 mSec.)
if(tcsetattr(sp->fd,TCSANOW,&sp->tiNew) == -1) if(tcsetattr(sp->fd,TCSANOW,&sp->tiNew) == -1)
{ {
uart_close(sp); uart_close(sp);
return INVALID_SERIAL_PORT; return INVALID_SERIAL_PORT;
} }
tcflush(sp->fd, TCIOFLUSH); tcflush(sp->fd, TCIOFLUSH);
return sp; return sp;
} }
void uart_set_speed(serial_port sp, const uint32_t uiPortSpeed) bool uart_set_speed(serial_port sp, const uint32_t uiPortSpeed) {
{
DBG("Serial port speed requested to be set to %d bauds.", uiPortSpeed);
// Set port speed (Input and Output) // Set port speed (Input and Output)
speed_t stPortSpeed = B9600;
switch(uiPortSpeed) {
case 9600: stPortSpeed = B9600;
break;
case 19200: stPortSpeed = B19200;
break;
case 38400: stPortSpeed = B38400;
break;
case 57600: stPortSpeed = B57600;
break;
case 115200: stPortSpeed = B115200;
break;
case 230400: stPortSpeed = B230400;
break;
#ifdef B460800
case 460800: stPortSpeed = B460800;
break;
#endif
default:
#ifdef B460800
ERR("Unable to set serial port speed to %d bauds. Speed value must be one of these constants: 9600 (default), 19200, 38400, 57600, 115200, 230400 or 460800.", uiPortSpeed);
#else
ERR("Unable to set serial port speed to %d bauds. Speed value must be one of these constants: 9600 (default), 19200, 38400, 57600, 115200 or 230400.", uiPortSpeed);
#endif
};
const serial_port_unix* spu = (serial_port_unix*)sp; const serial_port_unix* spu = (serial_port_unix*)sp;
cfsetispeed((struct termios*)&spu->tiNew, stPortSpeed); cfsetispeed((struct termios*)&spu->tiNew, uiPortSpeed);
cfsetospeed((struct termios*)&spu->tiNew, stPortSpeed); cfsetospeed((struct termios*)&spu->tiNew, uiPortSpeed);
if( tcsetattr(spu->fd, TCSADRAIN, &spu->tiNew) == -1) return (tcsetattr(spu->fd, TCSADRAIN, &spu->tiNew) != -1);
{
ERR("Unable to apply new speed settings.");
}
} }
uint32_t uart_get_speed(const serial_port sp) uint32_t uart_get_speed(const serial_port sp) {
{
uint32_t uiPortSpeed = 0; uint32_t uiPortSpeed = 0;
const serial_port_unix* spu = (serial_port_unix*)sp; const serial_port_unix* spu = (serial_port_unix*)sp;
switch (cfgetispeed(&spu->tiNew)) uiPortSpeed = cfgetispeed(&spu->tiNew);
{
case B9600: uiPortSpeed = 9600;
break;
case B19200: uiPortSpeed = 19200;
break;
case B38400: uiPortSpeed = 38400;
break;
case B57600: uiPortSpeed = 57600;
break;
case B115200: uiPortSpeed = 115200;
break;
case B230400: uiPortSpeed = 230400;
break;
#ifdef B460800
case B460800: uiPortSpeed = 460800;
break;
#endif
}
return uiPortSpeed; return uiPortSpeed;
} }
void uart_close(const serial_port sp) void uart_close(const serial_port sp) {
{
tcflush(((serial_port_unix*)sp)->fd,TCIOFLUSH); tcflush(((serial_port_unix*)sp)->fd,TCIOFLUSH);
tcsetattr(((serial_port_unix*)sp)->fd,TCSANOW,&((serial_port_unix*)sp)->tiOld); tcsetattr(((serial_port_unix*)sp)->fd,TCSANOW,&((serial_port_unix*)sp)->tiOld);
close(((serial_port_unix*)sp)->fd); close(((serial_port_unix*)sp)->fd);
free(sp); free(sp);
} }
bool uart_cts(const serial_port sp) bool uart_cts(const serial_port sp) {
{
char status; char status;
if (ioctl(((serial_port_unix*)sp)->fd,TIOCMGET,&status) < 0) return false; if (ioctl(((serial_port_unix*)sp)->fd,TIOCMGET,&status) < 0) return false;
return (status & TIOCM_CTS); return (status & TIOCM_CTS);
} }
bool uart_receive(const serial_port sp, byte_t* pbtRx, size_t* pszRxLen) bool uart_receive(const serial_port sp, byte_t* pbtRx, size_t* pszRxLen) {
{
int res; int res;
int byteCount; int byteCount;
fd_set rfds; fd_set rfds;
struct timeval tv; struct timeval tv;
// Reset the output count // Reset the output count
*pszRxLen = 0; *pszRxLen = 0;
do { do {
// Reset file descriptor // Reset file descriptor
FD_ZERO(&rfds); FD_ZERO(&rfds);
FD_SET(((serial_port_unix*)sp)->fd,&rfds); FD_SET(((serial_port_unix*)sp)->fd,&rfds);
tv = timeout; tv = timeout;
res = select(((serial_port_unix*)sp)->fd+1, &rfds, NULL, NULL, &tv); res = select(((serial_port_unix*)sp)->fd+1, &rfds, NULL, NULL, &tv);
// Read error // Read error
if (res < 0) { if (res < 0) {
DBG("RX error.");
return false; return false;
} }
// Read time-out // Read time-out
if (res == 0) { if (res == 0) {
if (*pszRxLen == 0) { if (*pszRxLen == 0) {
// Error, we received no data // Error, we received no data
DBG("RX time-out, buffer empty.");
return false; return false;
} else { } else {
// We received some data, but nothing more is available // We received some data, but nothing more is available
return true; return true;
} }
} }
// Retrieve the count of the incoming bytes // Retrieve the count of the incoming bytes
res = ioctl(((serial_port_unix*)sp)->fd, FIONREAD, &byteCount); res = ioctl(((serial_port_unix*)sp)->fd, FIONREAD, &byteCount);
if (res < 0) return false; if (res < 0) return false;
// There is something available, read the data // There is something available, read the data
res = read(((serial_port_unix*)sp)->fd,pbtRx+(*pszRxLen),byteCount); res = read(((serial_port_unix*)sp)->fd,pbtRx+(*pszRxLen),byteCount);
// Stop if the OS has some troubles reading the data // Stop if the OS has some troubles reading the data
if (res <= 0) return false; if (res <= 0) return false;
*pszRxLen += res; *pszRxLen += res;
} while (byteCount); } while (byteCount);
return true; return true;
} }
bool uart_send(const serial_port sp, const byte_t* pbtTx, const size_t szTxLen) bool uart_send(const serial_port sp, const byte_t* pbtTx, const size_t szTxLen) {
{
int32_t res; int32_t res;
size_t szPos = 0; size_t szPos = 0;
fd_set rfds; fd_set rfds;
struct timeval tv; struct timeval tv;
while (szPos < szTxLen) while (szPos < szTxLen)
{ {
// Reset file descriptor // Reset file descriptor
@ -258,25 +199,23 @@ bool uart_send(const serial_port sp, const byte_t* pbtTx, const size_t szTxLen)
FD_SET(((serial_port_unix*)sp)->fd,&rfds); FD_SET(((serial_port_unix*)sp)->fd,&rfds);
tv = timeout; tv = timeout;
res = select(((serial_port_unix*)sp)->fd+1, NULL, &rfds, NULL, &tv); res = select(((serial_port_unix*)sp)->fd+1, NULL, &rfds, NULL, &tv);
// Write error // Write error
if (res < 0) { if (res < 0) {
DBG("TX error.");
return false; return false;
} }
// Write time-out // Write time-out
if (res == 0) { if (res == 0) {
DBG("TX time-out.");
return false; return false;
} }
// Send away the bytes // Send away the bytes
res = write(((serial_port_unix*)sp)->fd,pbtTx+szPos,szTxLen-szPos); res = write(((serial_port_unix*)sp)->fd,pbtTx+szPos,szTxLen-szPos);
// Stop if the OS has some troubles sending the data // Stop if the OS has some troubles sending the data
if (res <= 0) return false; if (res <= 0) return false;
szPos += res; szPos += res;
} }
return true; return true;
@ -285,7 +224,7 @@ bool uart_send(const serial_port sp, const byte_t* pbtTx, const size_t szTxLen)
#else #else
// The windows serial port implementation // The windows serial port implementation
typedef struct { typedef struct {
HANDLE hPort; // Serial port handle HANDLE hPort; // Serial port handle
DCB dcb; // Device control settings DCB dcb; // Device control settings
COMMTIMEOUTS ct; // Serial port time-out configuration COMMTIMEOUTS ct; // Serial port time-out configuration
@ -300,15 +239,14 @@ void upcase(char *p) {
} }
} }
serial_port uart_open(const char* pcPortName) serial_port uart_open(const char* pcPortName) {
{
char acPortName[255]; char acPortName[255];
serial_port_windows* sp = malloc(sizeof(serial_port_windows)); serial_port_windows* sp = malloc(sizeof(serial_port_windows));
// Copy the input "com?" to "\\.\COM?" format // Copy the input "com?" to "\\.\COM?" format
sprintf(acPortName,"\\\\.\\%s",pcPortName); sprintf(acPortName,"\\\\.\\%s",pcPortName);
upcase(acPortName); upcase(acPortName);
// Try to open the serial port // Try to open the serial port
sp->hPort = CreateFileA(acPortName,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL); sp->hPort = CreateFileA(acPortName,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL);
if (sp->hPort == INVALID_HANDLE_VALUE) if (sp->hPort == INVALID_HANDLE_VALUE)
@ -316,7 +254,7 @@ serial_port uart_open(const char* pcPortName)
uart_close(sp); uart_close(sp);
return INVALID_SERIAL_PORT; return INVALID_SERIAL_PORT;
} }
// Prepare the device control // Prepare the device control
memset(&sp->dcb, 0, sizeof(DCB)); memset(&sp->dcb, 0, sizeof(DCB));
sp->dcb.DCBlength = sizeof(DCB); sp->dcb.DCBlength = sizeof(DCB);
@ -325,81 +263,57 @@ serial_port uart_open(const char* pcPortName)
uart_close(sp); uart_close(sp);
return INVALID_SERIAL_PORT; return INVALID_SERIAL_PORT;
} }
// Update the active serial port // Update the active serial port
if(!SetCommState(sp->hPort,&sp->dcb)) if(!SetCommState(sp->hPort,&sp->dcb))
{ {
uart_close(sp); uart_close(sp);
return INVALID_SERIAL_PORT; return INVALID_SERIAL_PORT;
} }
sp->ct.ReadIntervalTimeout = 0; sp->ct.ReadIntervalTimeout = 0;
sp->ct.ReadTotalTimeoutMultiplier = 0; sp->ct.ReadTotalTimeoutMultiplier = 0;
sp->ct.ReadTotalTimeoutConstant = 30; sp->ct.ReadTotalTimeoutConstant = 30;
sp->ct.WriteTotalTimeoutMultiplier = 0; sp->ct.WriteTotalTimeoutMultiplier = 0;
sp->ct.WriteTotalTimeoutConstant = 30; sp->ct.WriteTotalTimeoutConstant = 30;
if(!SetCommTimeouts(sp->hPort,&sp->ct)) if(!SetCommTimeouts(sp->hPort,&sp->ct))
{ {
uart_close(sp); uart_close(sp);
return INVALID_SERIAL_PORT; return INVALID_SERIAL_PORT;
} }
PurgeComm(sp->hPort, PURGE_RXABORT | PURGE_RXCLEAR); PurgeComm(sp->hPort, PURGE_RXABORT | PURGE_RXCLEAR);
return sp; return sp;
} }
void uart_close(const serial_port sp) void uart_close(const serial_port sp) {
{
CloseHandle(((serial_port_windows*)sp)->hPort); CloseHandle(((serial_port_windows*)sp)->hPort);
free(sp); free(sp);
} }
void uart_set_speed(serial_port sp, const uint32_t uiPortSpeed) bool uart_set_speed(serial_port sp, const uint32_t uiPortSpeed) {
{
serial_port_windows* spw; serial_port_windows* spw;
DBG("Serial port speed requested to be set to %d bauds.", uiPortSpeed);
// Set port speed (Input and Output)
switch(uiPortSpeed) {
case 9600:
case 19200:
case 38400:
case 57600:
case 115200:
case 230400:
case 460800:
break;
default:
ERR("Unable to set serial port speed to %d bauds. Speed value must be one of these constants: 9600 (default), 19200, 38400, 57600, 115200, 230400 or 460800.", uiPortSpeed);
};
spw = (serial_port_windows*)sp; spw = (serial_port_windows*)sp;
spw->dcb.BaudRate = uiPortSpeed; spw->dcb.BaudRate = uiPortSpeed;
if (!SetCommState(spw->hPort, &spw->dcb)) return SetCommState(spw->hPort, &spw->dcb);
{
ERR("Unable to apply new speed settings.");
}
} }
uint32_t uart_get_speed(const serial_port sp) uint32_t uart_get_speed(const serial_port sp) {
{
const serial_port_windows* spw = (serial_port_windows*)sp; const serial_port_windows* spw = (serial_port_windows*)sp;
if (!GetCommState(spw->hPort, (serial_port)&spw->dcb)) if (!GetCommState(spw->hPort, (serial_port)&spw->dcb)) {
return spw->dcb.BaudRate; return spw->dcb.BaudRate;
}
return 0; return 0;
} }
bool uart_receive(const serial_port sp, byte_t* pbtRx, size_t* pszRxLen) bool uart_receive(const serial_port sp, byte_t* pbtRx, size_t* pszRxLen) {
{
ReadFile(((serial_port_windows*)sp)->hPort,pbtRx,*pszRxLen,(LPDWORD)pszRxLen,NULL); ReadFile(((serial_port_windows*)sp)->hPort,pbtRx,*pszRxLen,(LPDWORD)pszRxLen,NULL);
return (*pszRxLen != 0); return (*pszRxLen != 0);
} }
bool uart_send(const serial_port sp, const byte_t* pbtTx, const size_t szTxLen) bool uart_send(const serial_port sp, const byte_t* pbtTx, const size_t szTxLen) {
{
DWORD dwTxLen = 0; DWORD dwTxLen = 0;
return WriteFile(((serial_port_windows*)sp)->hPort,pbtTx,szTxLen,&dwTxLen,NULL); return WriteFile(((serial_port_windows*)sp)->hPort,pbtTx,szTxLen,&dwTxLen,NULL);
return (dwTxLen != 0); return (dwTxLen != 0);

11
client/uart.h
View file

@ -1,7 +1,7 @@
/* /*
* Proxmark3 generic uart / rs232/ serial port library * Generic uart / rs232/ serial port library
* *
* Copyright (c) 2012, Roel Verdult * Copyright (c) 2013, Roel Verdult
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@ -31,8 +31,8 @@
* *
*/ */
#ifndef _PROXMARK3_RS232_H_ #ifndef _RS232_H_
#define _PROXMARK3_RS232_H_ #define _RS232_H_
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
@ -53,6 +53,7 @@ typedef unsigned char byte_t;
#include <sys/stat.h> #include <sys/stat.h>
#include <limits.h> #include <limits.h>
#include <sys/time.h> #include <sys/time.h>
#include <errno.h>
#else #else
#include <windows.h> #include <windows.h>
#endif #endif
@ -65,7 +66,7 @@ typedef void* serial_port;
serial_port uart_open(const char* pcPortName); serial_port uart_open(const char* pcPortName);
void uart_close(const serial_port sp); void uart_close(const serial_port sp);
void uart_set_speed(serial_port sp, const uint32_t uiPortSpeed); bool uart_set_speed(serial_port sp, const uint32_t uiPortSpeed);
uint32_t uart_get_speed(const serial_port sp); uint32_t uart_get_speed(const serial_port sp);
bool uart_receive(const serial_port sp, byte_t* pbtRx, size_t* pszRxLen); bool uart_receive(const serial_port sp, byte_t* pbtRx, size_t* pszRxLen);