#include <stdio.h>
#include <stdlib.h>
#include "common.h"
+#include "../common/config.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <limits.h>
#include <stdarg.h>
-#include <signal.h>
-#include <ident.h>
+#include <signal.h> // Signal handling
+#include <ident.h> // AUTHIDENT
+#include <time.h> // time(2)
+#include <ctype.h>
#define DEBUG_TRACE_CLIENT 0
#define HACK_NO_REFUNDS 1
+#define PIDFILE "/var/run/dispsrv.pid"
+
// Statistics
#define MAX_CONNECTION_QUEUE 5
#define INPUT_BUFFER_SIZE 256
int Socket; // Client socket ID
int ID; // Client ID
- int bIsTrusted; // Is the connection from a trusted host/port
+ int bTrustedHost;
+ int bCanAutoAuth; // Is the connection from a trusted host/port
char *Username;
char Salt[9];
// === PROTOTYPES ===
void Server_Start(void);
void Server_Cleanup(void);
-void Server_HandleClient(int Socket, int bTrusted);
+void Server_HandleClient(int Socket, int bTrustedHost, int bRootPort);
void Server_ParseClientCommand(tClient *Client, char *CommandString);
// --- Commands ---
void Server_Cmd_USER(tClient *Client, char *Args);
void Server_Cmd_PASS(tClient *Client, char *Args);
void Server_Cmd_AUTOAUTH(tClient *Client, char *Args);
void Server_Cmd_AUTHIDENT(tClient *Client, char *Args);
+void Server_Cmd_AUTHCARD(tClient* Client, char *Args);
void Server_Cmd_SETEUSER(tClient *Client, char *Args);
void Server_Cmd_ENUMITEMS(tClient *Client, char *Args);
void Server_Cmd_ITEMINFO(tClient *Client, char *Args);
void Server_Cmd_USERADD(tClient *Client, char *Args);
void Server_Cmd_USERFLAGS(tClient *Client, char *Args);
void Server_Cmd_UPDATEITEM(tClient *Client, char *Args);
+void Server_Cmd_PINCHECK(tClient *Client, char *Args);
+void Server_Cmd_PINSET(tClient *Client, char *Args);
+void Server_Cmd_CARDADD(tClient *Client, char *Args);
// --- Helpers ---
void Debug(tClient *Client, const char *Format, ...);
int sendf(int Socket, const char *Format, ...);
int Server_int_ParseArgs(int bUseLongArg, char *ArgStr, ...);
int Server_int_ParseFlags(tClient *Client, const char *Str, int *Mask, int *Value);
+#define CLIENT_DEBUG_LOW(Client, ...) do { if(giDebugLevel>1) Debug(Client, __VA_ARGS__); } while(0)
+#define CLIENT_DEBUG(Client, ...) do { if(giDebugLevel) Debug(Client, __VA_ARGS__); } while(0)
+
// === CONSTANTS ===
// - Commands
const struct sClientCommand {
{"PASS", Server_Cmd_PASS},
{"AUTOAUTH", Server_Cmd_AUTOAUTH},
{"AUTHIDENT", Server_Cmd_AUTHIDENT},
+ {"AUTHCARD", Server_Cmd_AUTHCARD},
{"SETEUSER", Server_Cmd_SETEUSER},
{"ENUM_ITEMS", Server_Cmd_ENUMITEMS},
{"ITEM_INFO", Server_Cmd_ITEMINFO},
{"USER_INFO", Server_Cmd_USERINFO},
{"USER_ADD", Server_Cmd_USERADD},
{"USER_FLAGS", Server_Cmd_USERFLAGS},
- {"UPDATE_ITEM", Server_Cmd_UPDATEITEM}
+ {"UPDATE_ITEM", Server_Cmd_UPDATEITEM},
+ {"PIN_CHECK", Server_Cmd_PINCHECK},
+ {"PIN_SET", Server_Cmd_PINSET},
+ {"CARD_ADD", Server_Cmd_CARDADD},
};
#define NUM_COMMANDS ((int)(sizeof(gaServer_Commands)/sizeof(gaServer_Commands[0])))
int gbServer_RunInBackground = 0;
char *gsServer_LogFile = "/var/log/dispsrv.log";
char *gsServer_ErrorLog = "/var/log/dispsrv.err";
+ int giServer_NumTrustedHosts;
+struct in_addr *gaServer_TrustedHosts;
// - State variables
int giServer_Socket; // Server socket
int giServer_NextClientID = 1; // Debug client ID
int client_socket;
struct sockaddr_in server_addr, client_addr;
- atexit(Server_Cleanup);
+ // Parse trusted hosts list
+ giServer_NumTrustedHosts = Config_GetValueCount("trusted_host");
+ gaServer_TrustedHosts = malloc(giServer_NumTrustedHosts * sizeof(*gaServer_TrustedHosts));
+ for( int i = 0; i < giServer_NumTrustedHosts; i ++ )
+ {
+ const char *addr = Config_GetValue_Idx("trusted_host", i);
+
+ if( inet_aton(addr, &gaServer_TrustedHosts[i]) == 0 ) {
+ fprintf(stderr, "Invalid IP address '%s'\n", addr);
+ continue ;
+ }
+ }
+
// Ignore SIGPIPE (stops crashes when the client exits early)
signal(SIGPIPE, SIG_IGN);
if( bind(giServer_Socket, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0 ) {
fprintf(stderr, "ERROR: Unable to bind to 0.0.0.0:%i\n", giServer_Port);
perror("Binding");
+ close(giServer_Socket);
return ;
}
}
if( pid != 0 ) {
// Parent, quit
+ Debug_Notice("Forked child server as PID %i\n", pid);
exit(0);
}
// In child
freopen("/dev/null", "r", stdin);
freopen(gsServer_LogFile, "a", stdout);
freopen(gsServer_ErrorLog, "a", stderr);
+ fprintf(stdout, "OpenDispense 2 Server Started at %lld\n", (long long)time(NULL));
+ fprintf(stderr, "OpenDispense 2 Server Started at %lld\n", (long long)time(NULL));
#endif
}
+ atexit(Server_Cleanup);
// Start the helper thread
StartPeriodicThread();
return ;
}
- printf("Listening on 0.0.0.0:%i\n", giServer_Port);
+ Debug_Notice("Listening on 0.0.0.0:%i", giServer_Port);
// write pidfile
{
- FILE *fp = fopen("/var/run/dispsrv.pid", "w");
+ FILE *fp = fopen(PIDFILE, "w");
if( fp ) {
fprintf(fp, "%i", getpid());
fclose(fp);
{
uint len = sizeof(client_addr);
int bTrusted = 0;
+ int bRootPort = 0;
// Accept a connection
client_socket = accept(giServer_Socket, (struct sockaddr *) &client_addr, &len);
if(giDebugLevel >= 2) {
char ipstr[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &client_addr.sin_addr, ipstr, INET_ADDRSTRLEN);
- printf("Client connection from %s:%i\n",
+ Debug_Debug("Client connection from %s:%i",
ipstr, ntohs(client_addr.sin_port));
}
// Doesn't matter what, localhost is trusted
if( ntohl( client_addr.sin_addr.s_addr ) == 0x7F000001 )
bTrusted = 1;
-
- // Trusted Connections
+
+ // Check if the host is on the trusted list
+ for( int i = 0; i < giServer_NumTrustedHosts; i ++ )
+ {
+ if( memcmp(&client_addr.sin_addr, &gaServer_TrustedHosts[i], sizeof(struct in_addr)) == 0 )
+ {
+ bTrusted = 1;
+ break;
+ }
+ }
+
+ // Root port (can AUTOAUTH if also a trusted machine
if( ntohs(client_addr.sin_port) < 1024 )
+ bRootPort = 1;
+
+ #if 0
{
// TODO: Make this runtime configurable
switch( ntohl( client_addr.sin_addr.s_addr ) )
break;
}
}
+ #endif
// TODO: Multithread this?
- Server_HandleClient(client_socket, bTrusted);
+ Server_HandleClient(client_socket, bTrusted, bRootPort);
close(client_socket);
}
void Server_Cleanup(void)
{
- printf("\nClose(%i)\n", giServer_Socket);
+ Debug_Debug("Close(%i)", giServer_Socket);
close(giServer_Socket);
- unlink("/var/run/dispsrv.pid");
+ unlink(PIDFILE);
}
/**
* \param Socket Client socket number/handle
* \param bTrusted Is the client trusted?
*/
-void Server_HandleClient(int Socket, int bTrusted)
+void Server_HandleClient(int Socket, int bTrusted, int bRootPort)
{
char inbuf[INPUT_BUFFER_SIZE];
char *buf = inbuf;
// Initialise Client info
clientInfo.Socket = Socket;
clientInfo.ID = giServer_NextClientID ++;
- clientInfo.bIsTrusted = bTrusted;
+ clientInfo.bTrustedHost = bTrusted;
+ clientInfo.bCanAutoAuth = bTrusted && bRootPort;
clientInfo.EffectiveUID = -1;
// Read from client
#endif
}
+/// UID: User ID (must be valid)
+/// username: Optional username
+bool authenticate(tClient* Client, int UID, const char* username)
+{
+ Client->UID = UID;
+
+ int flags = Bank_GetFlags(Client->UID);
+ if( flags & USER_FLAG_DISABLED ) {
+ Client->UID = -1;
+ sendf(Client->Socket, "403 Authentication failure: account disabled\n");
+ return false;
+ }
+ // You can't be an internal account
+ if( flags & USER_FLAG_INTERNAL ) {
+ if(giDebugLevel)
+ Debug(Client, "IDENT auth as '%s', not allowed", username);
+ Client->UID = -1;
+ sendf(Client->Socket, "403 Authentication failure: that account is internal\n");
+ return false;
+ }
+
+ // Save username
+ if(Client->Username != username)
+ {
+ if(Client->Username)
+ {
+ free(Client->Username);
+ }
+
+ // Fetch username (if not provided)
+ if( username )
+ {
+ Client->Username = strdup(username);
+ }
+ else
+ {
+ Client->Username = Bank_GetAcctName(UID);
+ }
+ }
+
+ Client->bIsAuthed = 1;
+
+ if(giDebugLevel)
+ Debug(Client, "Auto authenticated as '%s' (%i)", Client->Username, Client->UID);
+ return true;
+}
+bool require_auth(tClient* Client)
+{
+ // Check authentication
+ if( !Client->bIsAuthed ) {
+ sendf(Client->Socket, "401 Not Authenticated\n");
+ return false;
+ }
+ return true;
+}
+
/**
* \brief Authenticate as a user
*
void Server_Cmd_PASS(tClient *Client, char *Args)
{
char *passhash;
- int flags;
if( Server_int_ParseArgs(0, Args, &passhash, NULL) )
{
}
// Pass on to cokebank
- Client->UID = Bank_GetUserAuth(Client->Salt, Client->Username, passhash);
-
- if( Client->UID == -1 ) {
- sendf(Client->Socket, "401 Auth Failure\n");
- return ;
- }
-
- flags = Bank_GetFlags(Client->UID);
- if( flags & USER_FLAG_DISABLED ) {
- Client->UID = -1;
- sendf(Client->Socket, "403 Account Disabled\n");
+ int uid = Bank_GetUserAuth(Client->Salt, Client->Username, passhash);
+ if( uid < 0 ) {
+ if(giDebugLevel)
+ Debug(Client, "Unknown user '%s'", Client->Username);
+ sendf(Client->Socket, "403 Authentication failure: unknown account\n");
return ;
}
- if( flags & USER_FLAG_INTERNAL ) {
- Client->UID = -1;
- sendf(Client->Socket, "403 Internal account\n");
- return ;
+ if( ! authenticate(Client, uid, Client->Username) )
+ {
+ return;
}
-
- Client->bIsAuthed = 1;
sendf(Client->Socket, "200 Auth OK\n");
}
void Server_Cmd_AUTOAUTH(tClient *Client, char *Args)
{
char *username;
- int userflags;
if( Server_int_ParseArgs(0, Args, &username, NULL) )
{
}
// Check if trusted
- if( !Client->bIsTrusted ) {
+ if( !Client->bCanAutoAuth ) {
if(giDebugLevel)
Debug(Client, "Untrusted client attempting to AUTOAUTH");
sendf(Client->Socket, "401 Untrusted\n");
}
// Get UID
- Client->UID = Bank_GetAcctByName( username, 0 );
- if( Client->UID < 0 ) {
+ int uid = Bank_GetAcctByName( username, /*bCreate=*/0 );
+ if( uid < 0 ) {
if(giDebugLevel)
Debug(Client, "Unknown user '%s'", username);
- sendf(Client->Socket, "403 Auth Failure\n");
- return ;
- }
-
- userflags = Bank_GetFlags(Client->UID);
- // You can't be an internal account
- if( userflags & USER_FLAG_INTERNAL ) {
- if(giDebugLevel)
- Debug(Client, "Autoauth as '%s', not allowed", username);
- Client->UID = -1;
- sendf(Client->Socket, "403 Account is internal\n");
+ sendf(Client->Socket, "403 Authentication failure: unknown account\n");
return ;
}
-
- // Disabled accounts
- if( userflags & USER_FLAG_DISABLED ) {
- Client->UID = -1;
- sendf(Client->Socket, "403 Account disabled\n");
- return ;
+ if( ! authenticate(Client, uid, username) )
+ {
+ return;
}
-
- // Save username
- if(Client->Username)
- free(Client->Username);
- Client->Username = strdup(username);
-
- Client->bIsAuthed = 1;
-
- if(giDebugLevel)
- Debug(Client, "Auto authenticated as '%s' (%i)", username, Client->UID);
sendf(Client->Socket, "200 Auth OK\n");
}
void Server_Cmd_AUTHIDENT(tClient *Client, char *Args)
{
char *username;
- int userflags;
- const int ident_timeout = 5;
- socklen_t len;
- struct sockaddr_in client_addr;
- uint32_t client_ip;
+ const int IDENT_TIMEOUT = 5;
if( Args != NULL && strlen(Args) ) {
sendf(Client->Socket, "407 AUTHIDENT takes no arguments\n");
return ;
}
- // Check if trusted (only works with INET sockets at present)
- len = sizeof(client_addr);
- if ( ! getpeername(Client->Socket, (struct sockaddr*)&client_addr, &len) ) {
- // throw an error
- }
-
- client_ip = client_addr.sin_addr.s_addr;
- if ( ! (ntohl(client_ip) == 0x7F000001 || ( (ntohl(client_ip) & IDENT_TRUSTED_NETMASK) == IDENT_TRUSTED_NETWORK ) )) {
- if(giDebugLevel)
- Debug(Client, "Untrusted client attempting to AUTHIDENT");
- sendf(Client->Socket, "401 Untrusted\n");
- return ;
+ // Check if trusted
+ if( !Client->bTrustedHost ) {
+ if(giDebugLevel)
+ Debug(Client, "Untrusted client attempting to AUTHIDENT");
+ sendf(Client->Socket, "401 Untrusted\n");
+ return ;
}
// Get username via IDENT
- username = ident_id(Client->Socket, ident_timeout);
- if (!username) {
+ username = ident_id(Client->Socket, IDENT_TIMEOUT);
+ if( !username ) {
+ perror("AUTHIDENT - IDENT timed out");
sendf(Client->Socket, "403 Authentication failure: IDENT auth timed out\n");
+ return ;
}
- // Get UID
- Client->UID = Bank_GetAcctByName( username, 0 );
- if( Client->UID < 0 ) {
+ int uid = Bank_GetAcctByName(username, /*bCreate=*/0);
+ if( uid < 0 ) {
if(giDebugLevel)
Debug(Client, "Unknown user '%s'", username);
sendf(Client->Socket, "403 Authentication failure: unknown account\n");
free(username);
return ;
}
-
- userflags = Bank_GetFlags(Client->UID);
- // You can't be an internal account
- if( userflags & USER_FLAG_INTERNAL ) {
- if(giDebugLevel)
- Debug(Client, "IDENT auth as '%s', not allowed", username);
- Client->UID = -1;
- sendf(Client->Socket, "403 Authentication failure: that account is internal\n");
+ if( ! authenticate(Client, uid, username) )
+ {
free(username);
return ;
}
+ free(username);
- // Disabled accounts
- if( userflags & USER_FLAG_DISABLED ) {
- Client->UID = -1;
- sendf(Client->Socket, "403 Authentication failure: account disabled\n");
- free(username);
+ sendf(Client->Socket, "200 Auth OK\n");
+}
+
+void Server_Cmd_AUTHCARD(tClient* Client, char *Args)
+{
+ char* card_id;
+ if( Server_int_ParseArgs(0, Args, &card_id, NULL) )
+ {
+ sendf(Client->Socket, "407 AUTHCARD takes 1 argument\n");
return ;
}
- // Save username
- if(Client->Username)
- free(Client->Username);
- Client->Username = strdup(username);
-
- Client->bIsAuthed = 1;
+ // Check if trusted (has to be root)
+ if( Client->UID != 1 )
+ {
+ if(giDebugLevel)
+ Debug(Client, "Attempting to use AUTHCARD as non-root");
+ sendf(Client->Socket, "401 Untrusted\n");
+ return ;
+ }
- if(giDebugLevel)
- Debug(Client, "IDENT authenticated as '%s' (%i)", username, Client->UID);
- free(username);
+ CLIENT_DEBUG(Client, "MIFARE auth with '%s'", card_id);
+ int uid = Bank_GetAcctByCard(card_id);
+ if( uid < 0 )
+ {
+ if(giDebugLevel)
+ Debug(Client, "Unknown MIFARE '%s'", card_id);
+ sendf(Client->Socket, "403 Authentication failure: unknown MIFARE ID\n");
+ return ;
+ }
+ if( ! authenticate(Client, uid, NULL) )
+ {
+ return ;
+ }
- sendf(Client->Socket, "200 Auth OK\n");
+ sendf(Client->Socket, "200 Auth Ok, username=%s\n", Client->Username);
}
/**
sendf(Client->Socket, "404 User not found\n");
return ;
}
-
- // You can't be an internal account
+ // You can't be an internal account (unless you're an admin)
if( !(userFlags & USER_FLAG_ADMIN) )
{
eUserFlags = Bank_GetFlags(Client->EffectiveUID);
sendf(Client->Socket, "404 User not found\n");
return ;
}
- // Disabled only avaliable to admins
- if( eUserFlags & USER_FLAG_DISABLED ) {
- Client->EffectiveUID = -1;
- sendf(Client->Socket, "403 Account disabled\n");
- return ;
- }
+ }
+
+ // Disabled accounts
+ // - If disabled and the actual user is not an admin (and not root)
+ // return 403
+ if( (eUserFlags & USER_FLAG_DISABLED) && (Client->UID == 0 || !(userFlags & USER_FLAG_ADMIN)) ) {
+ Client->EffectiveUID = -1;
+ sendf(Client->Socket, "403 Account disabled\n");
+ return ;
}
sendf(Client->Socket, "200 User set\n");
}
}
+ if( !gbNoCostMode && Item->Price == 0 )
+ status = "error";
// KNOWN HACK: Naming a slot 'dead' disables it
if( strcmp(Item->Name, "dead") == 0 )
status = "sold"; // Another status?
/**
* \brief Fetch information on a specific item
+ *
+ * Usage: ITEMINFO <item ID>
*/
void Server_Cmd_ITEMINFO(tClient *Client, char *Args)
{
Server_int_SendItem( Client, item );
}
+/**
+ * \brief Dispense an item
+ *
+ * Usage: DISPENSE <Item ID>
+ */
void Server_Cmd_DISPENSE(tClient *Client, char *Args)
{
tItem *item;
uid = Client->UID;
}
+// if( Bank_GetFlags(Client->UID) & USER_FLAG_DISABLED ) {
+// }
+
switch( ret = DispenseItem( Client->UID, uid, item ) )
{
case 0: sendf(Client->Socket, "200 Dispense OK\n"); return ;
}
}
+/**
+ * \brief Refund an item to a user
+ *
+ * Usage: REFUND <user> <item id> [<price>]
+ */
void Server_Cmd_REFUND(tClient *Client, char *Args)
{
tItem *item;
}
}
+/**
+ * \brief Transfer money to another account
+ *
+ * Usage: GIVE <dest> <ammount> <reason...>
+ */
void Server_Cmd_GIVE(tClient *Client, char *Args)
{
char *recipient, *ammount, *reason;
if( !(Bank_GetFlags(Client->UID) & USER_FLAG_ADMIN) )
{
if( Bank_GetFlags(uid) & USER_FLAG_INTERNAL ) {
- sendf(Client->Socket, "404 Invalid user\n");
+ sendf(Client->Socket, "403 Admin only\n");
return ;
}
// TODO: Maybe disallow changes to disabled?
return ;
}
+ int origBalance, rv;
// Do give
- switch( DispenseSet(Client->UID, uid, iAmmount, reason) )
+ switch( rv = DispenseSet(Client->UID, uid, iAmmount, reason, &origBalance) )
{
case 0:
- sendf(Client->Socket, "200 Add OK\n");
- return ;
- case 2:
- sendf(Client->Socket, "402 Poor Guy\n");
+ sendf(Client->Socket, "200 Add OK (%i)\n", origBalance);
return ;
default:
- sendf(Client->Socket, "500 Unknown error\n");
+ sendf(Client->Socket, "500 Unknown error (%i)\n", rv);
return ;
}
}
}
// Check authentication
- if( !Client->bIsAuthed ) {
- sendf(Client->Socket, "401 Not Authenticated\n");
- return ;
- }
+ if(!require_auth(Client)) return;
// Check permissions
if( !(Bank_GetFlags(Client->UID) & USER_FLAG_ADMIN) ) {
sendf(Client->Socket, "407 UPDATE_ITEM takes 3 arguments\n");
return ;
}
-
- if( !Client->bIsAuthed ) {
- sendf(Client->Socket, "401 Not Authenticated\n");
- return ;
- }
+
+ if(!require_auth(Client)) return;
// Check user permissions
if( !(Bank_GetFlags(Client->UID) & (USER_FLAG_COKE|USER_FLAG_ADMIN)) ) {
}
}
+void Server_Cmd_PINCHECK(tClient *Client, char *Args)
+{
+ char *username, *pinstr;
+ int pin;
+
+ if( Server_int_ParseArgs(0, Args, &username, &pinstr, NULL) ) {
+ sendf(Client->Socket, "407 PIN_CHECK takes 2 arguments\n");
+ return ;
+ }
+
+ if( !isdigit(pinstr[0]) || !isdigit(pinstr[1]) || !isdigit(pinstr[2]) || !isdigit(pinstr[3]) || pinstr[4] != '\0' ) {
+ sendf(Client->Socket, "407 PIN should be four digits\n");
+ return ;
+ }
+ pin = atoi(pinstr);
+
+ if(!require_auth(Client)) return;
+
+ // Get user
+ int uid = Bank_GetAcctByName(username, 0);
+ if( uid == -1 ) {
+ sendf(Client->Socket, "404 User '%s' not found\n", username);
+ return ;
+ }
+
+ // Check user permissions
+ if( uid != Client->UID && !(Bank_GetFlags(Client->UID) & (USER_FLAG_COKE|USER_FLAG_ADMIN)) ) {
+ sendf(Client->Socket, "403 Not in coke\n");
+ return ;
+ }
+
+ // Get the pin
+ static time_t last_wrong_pin_time;
+ static int backoff = 1;
+ if( time(NULL) - last_wrong_pin_time < backoff ) {
+ sendf(Client->Socket, "407 Rate limited (%i seconds remaining)\n",
+ backoff - (time(NULL) - last_wrong_pin_time));
+ return ;
+ }
+ last_wrong_pin_time = time(NULL);
+ if( !Bank_IsPinValid(uid, pin) )
+ {
+ sendf(Client->Socket, "401 Pin incorrect\n");
+ struct sockaddr_storage addr;
+ socklen_t len = sizeof(addr);
+ char ipstr[INET6_ADDRSTRLEN];
+ getpeername(Client->Socket, (void*)&addr, &len);
+ struct sockaddr_in *s = (struct sockaddr_in *)&addr;
+ inet_ntop(addr.ss_family, &s->sin_addr, ipstr, sizeof(ipstr));
+ Debug_Notice("Bad pin from %s for %s by %i", ipstr, username, Client->UID);
+ if( backoff < 5)
+ backoff ++;
+ return ;
+ }
+
+ last_wrong_pin_time = 0;
+ backoff = 1;
+ sendf(Client->Socket, "200 Pin correct\n");
+ return ;
+}
+void Server_Cmd_PINSET(tClient *Client, char *Args)
+{
+ char *pinstr;
+ int pin;
+
+
+ if( Server_int_ParseArgs(0, Args, &pinstr, NULL) ) {
+ sendf(Client->Socket, "407 PIN_SET takes 1 argument\n");
+ return ;
+ }
+
+ if( !isdigit(pinstr[0]) || !isdigit(pinstr[1]) || !isdigit(pinstr[2]) || !isdigit(pinstr[3]) || pinstr[4] != '\0' ) {
+ sendf(Client->Socket, "407 PIN should be four digits\n");
+ return ;
+ }
+ pin = atoi(pinstr);
+
+ if(!require_auth(Client)) return;
+
+ int uid = Client->EffectiveUID > 0 ? Client->EffectiveUID : Client->UID;
+ CLIENT_DEBUG(Client, "Setting PIN for UID %i", uid);
+ // Can only pinset yourself (well, the effective user)
+ Bank_SetPin(uid, pin);
+ sendf(Client->Socket, "200 Pin updated\n");
+ return ;
+}
+void Server_Cmd_CARDADD(tClient* Client, char* Args)
+{
+ char* card_id;
+ if( Server_int_ParseArgs(0, Args, &card_id, NULL) ) {
+ sendf(Client->Socket, "407 CARD_ADD takes 1 argument\n");
+ return ;
+ }
+
+ if(!require_auth(Client)) return;
+
+ int uid = Client->EffectiveUID > 0 ? Client->EffectiveUID : Client->UID;
+ CLIENT_DEBUG(Client, "Add card '%s' to UID %i", card_id, uid);
+ if( Bank_AddAcctCard(uid, card_id) )
+ {
+ sendf(Client->Socket, "408 Card already exists\n");
+ return ;
+ }
+ sendf(Client->Socket, "200 Card added\n");
+}
+
// --- INTERNAL HELPERS ---
void Debug(tClient *Client, const char *Format, ...)
{
return 0;
}
+
git.ucc.asn.au / tpg / opendispense2.git / blobdiff
UCC git Repository :: git.ucc.asn.au