From 10f6c2976cd8980d5b8b1b7eec1a6d8219b0c4b7 Mon Sep 17 00:00:00 2001 From: obrien Date: Tue, 3 Aug 2004 17:12:30 +0000 Subject: Pull in large chunks of the unreleased changes on the STABLE_1_3 branch. This stops the segfaulting on any auction add that started in July. --- misc/bidwatcher/Makefile | 2 +- misc/bidwatcher/files/patch-Makefile.in | 8 + misc/bidwatcher/files/patch-STABLE_1_3 | 1767 +++++++++++++++++++++++++++++++ 3 files changed, 1776 insertions(+), 1 deletion(-) create mode 100644 misc/bidwatcher/files/patch-Makefile.in create mode 100644 misc/bidwatcher/files/patch-STABLE_1_3 (limited to 'misc') diff --git a/misc/bidwatcher/Makefile b/misc/bidwatcher/Makefile index a28dffd4..50eab2d 100644 --- a/misc/bidwatcher/Makefile +++ b/misc/bidwatcher/Makefile @@ -8,7 +8,7 @@ PORTNAME= bidwatcher PORTVERSION= 1.3.15 -PORTREVISION?= 0 +PORTREVISION?= 1 CATEGORIES= misc MASTER_SITES= ${MASTER_SITE_SOURCEFORGE} MASTER_SITE_SUBDIR= ${PORTNAME} diff --git a/misc/bidwatcher/files/patch-Makefile.in b/misc/bidwatcher/files/patch-Makefile.in new file mode 100644 index 0000000..511057e --- /dev/null +++ b/misc/bidwatcher/files/patch-Makefile.in @@ -0,0 +1,8 @@ +--- Makefile.in.orig Fri Apr 23 13:30:42 2004 ++++ Makefile.in Tue Aug 3 08:57:03 2004 +@@ -83 +83 @@ +-bidwatcher_SOURCES = bidwatcher.cpp helpers.cpp netstuff.cpp bidwatcher.h ++bidwatcher_SOURCES = bidwatcher.cpp helpers.cpp netstuff.cpp bidwatcher.h bidgui.cpp bidgroup.cpp +@@ -99 +99 @@ +-bidwatcher_OBJECTS = bidwatcher.o helpers.o netstuff.o ++bidwatcher_OBJECTS = bidwatcher.o helpers.o netstuff.o bidgui.o bidgroup.o diff --git a/misc/bidwatcher/files/patch-STABLE_1_3 b/misc/bidwatcher/files/patch-STABLE_1_3 new file mode 100644 index 0000000..ed07a73 --- /dev/null +++ b/misc/bidwatcher/files/patch-STABLE_1_3 @@ -0,0 +1,1767 @@ +diff -u -ruN -b -B -w /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidgroup.cpp anoncvs-STABLE_1_3/bidgroup.cpp +--- /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidgroup.cpp Wed Dec 31 16:00:00 1969 ++++ bidgroup.cpp Thu Jun 10 02:02:08 2004 +@@ -0,0 +1,191 @@ ++ ++// Copyright (C) 2004 Planet Intelligent Systems GmbH ++// Residence Park 1-7, 19065 Raben Steinfeld, Germany, Europe, Earth ++// All rights reserved ++// ++// Author: Jan Starzynski ++// ++// $Id: bidgroup.cpp,v 1.1.2.1 2004/06/10 09:02:08 sturnus Exp $ ++// ++// $Log: bidgroup.cpp,v $ ++// Revision 1.1.2.1 2004/06/10 09:02:08 sturnus ++// files for bidgroups and extensions ++// ++// Revision 1.13 2004/05/18 13:29:50 js02 ++// integration continued ++// ++// Revision 1.12 2004/05/17 23:33:33 js02 ++// bid groups continued ++// ++// Revision 1.10 2004/05/14 16:30:39 js02 ++// bidgroup control via middle mouse button implemented ++// ++// Revision 1.9 2004/05/13 21:54:57 js02 ++// View and Control for Bidgroups ++// ++// Revision 1.8 2004/05/13 15:38:07 js02 ++// new function groupId ++// ++// Revision 1.7 2004/05/13 11:31:39 js02 ++// Load/Save of BidGroups ++// ++// Revision 1.6 2004/05/13 09:56:29 js02 ++// vereinfachte Version ++// ++ ++#include ++#include ++ ++#include "bidgroup.h" ++ ++using namespace std; ++ ++struct FindItem: public unary_function { ++ BidGroup::IdType id; ++ FindItem(BidGroup::IdType id): id(id) {} ++ bool operator()(const BidGroup::ItemList &list) const { return list.find(id) != list.end(); } ++}; ++ ++struct UselessList: public unary_function { ++ bool operator()(const BidGroup::ItemList &list) const { return list.size() <= 1; } ++}; ++ ++void BidGroup::clear() ++{ ++ m_list.clear(); ++} ++ ++int BidGroup::numGroup() const ++{ ++ return m_list.size(); ++} ++ ++BidGroup::ItemList *BidGroup::addItem(const IdType &id1, const IdType &id2) ++{ ++ ItemList *item; ++ ++ item = findItem(id1); ++ if(item) { ++ item->insert(id2); ++ return item; ++ } ++ ++ item = findItem(id2); ++ if(item) { ++ item->insert(id1); ++ return item; ++ } ++ ++ if(id1 == id2) return 0; ++ ++ ItemList add; ++ add.insert(id1); ++ add.insert(id2); ++ GroupList::iterator insert = find_if(m_list.begin(), m_list.end(), UselessList()); ++ if(insert == m_list.end()) { ++ m_list.insert(insert, add); ++ } else { ++ *insert = add; ++ } ++ ++ return &m_list.back(); ++} ++ ++int BidGroup::groupId(const IdType &id) const ++{ ++ GroupList::const_iterator it = find_if(m_list.begin(), m_list.end(), FindItem(id)); ++ return it == m_list.end() ? -1 : it - m_list.begin(); ++} ++ ++BidGroup::ItemList *BidGroup::findItemP(const IdType &id) const ++{ ++ return getGroupP(groupId(id)); ++} ++ ++BidGroup::ItemList *BidGroup::getGroupP(int gid) const ++{ ++ return const_cast(gid < 0 || gid >= numGroup() ? 0 : &m_list[gid]); ++} ++ ++bool BidGroup::delItem(const IdType &id) ++{ ++ bool ok = false; ++ for(GroupList::iterator it = m_list.begin(); it != m_list.end(); ++it) { ++ ok |= it->erase(id); ++ } ++ return ok; ++} ++ ++vector &BidGroup::findItem(vector &vec, const IdType &id) ++{ ++ ItemList *item = findItem(id); ++ if(id) vec.insert(vec.end(), item->begin(), item->end()); ++ return vec; ++} ++ ++bool BidGroup::read(const char *file) ++{ ++ FILE *fp = fopen(file, "r"); ++ bool ret = read(fp); ++ if(fp) fclose(fp); ++ return ret; ++} ++ ++bool BidGroup::write(const char *file) const ++{ ++ FILE *fp = fopen(file, "w"); ++ bool ret = write(fp); ++ if(fp) fclose(fp); ++ return ret; ++} ++ ++bool BidGroup::read(FILE *fp) ++{ ++ if(!fp) return false; ++ ++ bool ok = true; ++ char buffer[30]; ++ ++ ItemList group; ++ while(fgets(buffer, sizeof(buffer), fp)) { ++ IdType id; ++ if(sscanf(buffer, "%llu", &id) == 1) { ++ group.insert(id); ++ } else { ++ if(!group.empty()) { ++ m_list.push_back(group); ++ group.clear(); ++ } ++ } ++ } ++ ++ if(!group.empty()) m_list.push_back(group); ++ ++ return ok; ++} ++ ++bool BidGroup::write(FILE *fp) const ++{ ++ if(!fp) return false; ++ ++ bool ok = true; ++ for(GroupList::const_iterator it = m_list.begin(); it != m_list.end(); ++it) { ++ if(!it->empty()) { ++ for(ItemList::const_iterator jt = it->begin(); jt != it->end(); ++jt) { ++ fprintf(fp, "%llu\n", *jt); ++ } ++ fprintf(fp, "\n"); ++ } ++ } ++ return ok; ++} ++ ++void BidGroup::sweepList(bool at_end_only) ++{ ++ if(at_end_only) { ++ m_list.erase(find_if(m_list.rbegin(), m_list.rend(), not1(UselessList())).base(), m_list.end()); ++ } else { ++ m_list.erase(remove_if(m_list.begin(), m_list.end(), UselessList()), m_list.end()); ++ } ++} ++ +diff -u -ruN -b -B -w /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidgroup.h anoncvs-STABLE_1_3/bidgroup.h +--- /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidgroup.h Wed Dec 31 16:00:00 1969 ++++ bidgroup.h Thu Jul 15 07:27:30 2004 +@@ -0,0 +1,82 @@ ++ ++/* ++ * Copyright (C) 2004 Planet Intelligent Systems GmbH ++ * Residence Park 1-7, 19065 Raben Steinfeld, Germany, Europe, Earth ++ * All rights reserved ++ * ++ * Author: Jan Starzynski ++ * ++ * $Id: bidgroup.h,v 1.1.2.2 2004/07/15 14:27:30 sturnus Exp $ ++ * ++ * $Log: bidgroup.h,v $ ++ * Revision 1.1.2.2 2004/07/15 14:27:30 sturnus ++ * #include + std::FILE added ++ * ++ * Revision 1.1.2.1 2004/06/10 09:02:08 sturnus ++ * files for bidgroups and extensions ++ * ++ * Revision 1.12 2004/05/18 13:29:50 js02 ++ * integration continued ++ * ++ * Revision 1.11 2004/05/17 23:33:33 js02 ++ * bid groups continued ++ * ++ * Revision 1.9 2004/05/14 16:30:39 js02 ++ * bidgroup control via middle mouse button implemented ++ * ++ * Revision 1.8 2004/05/13 21:54:57 js02 ++ * View and Control for Bidgroups ++ * ++ * Revision 1.7 2004/05/13 15:38:07 js02 ++ * new function groupId ++ * ++ * Revision 1.6 2004/05/13 11:31:39 js02 ++ * Load/Save of BidGroups ++ * ++ * Revision 1.5 2004/05/13 09:56:29 js02 ++ * vereinfachte Version ++ * ++ */ ++ ++#ifndef BIDWATCHER_BIDGROUP_H ++#define BIDWATCHER_BIDGROUP_H ++ ++#include ++#include ++#include ++ ++class BidGroup { ++public: ++ typedef unsigned long long IdType; ++ typedef std::set ItemList; ++ typedef std::vector GroupList; ++ ++ void clear(); ++ int numGroup() const; ++ ++ ItemList *addItem(const IdType &id1, const IdType &id2); ++ bool delItem(const IdType &id); ++ ++ int groupId(const IdType &id) const; ++ const ItemList *getGroup(int idx) const { return getGroupP(idx); } ++ ItemList *getGroup(int idx) { return getGroupP(idx); } ++ ++ const ItemList *findItem(const IdType &id) const { return findItemP(id); } ++ ItemList *findItem(const IdType &id) { return findItemP(id); } ++ std::vector &findItem(std::vector &vec, const IdType &id); ++ ++ void sweepList(bool at_end_only = true); ++ ++ bool read(const char *file); ++ bool read(std::FILE *fp); ++ ++ bool write(const char *file) const; ++ bool write(std::FILE *fp) const; ++ ++private: ++ GroupList m_list; ++ ItemList *findItemP(const IdType &id) const; ++ ItemList *getGroupP(int idx) const; ++}; ++ ++#endif +diff -u -ruN -b -B -w /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidgui.cpp anoncvs-STABLE_1_3/bidgui.cpp +--- /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidgui.cpp Wed Dec 31 16:00:00 1969 ++++ bidgui.cpp Mon Jul 12 01:02:55 2004 +@@ -0,0 +1,398 @@ ++ ++// Copyright (C) 2004 Planet Intelligent Systems GmbH ++// Residence Park 1-7, 19065 Raben Steinfeld, Germany, Europe, Earth ++// All rights reserved ++// ++// Author: Jan Starzynski ++// ++// $Id: bidgui.cpp,v 1.1.2.4 2004/07/12 08:02:55 sturnus Exp $ ++// ++// $Log: bidgui.cpp,v $ ++// Revision 1.1.2.4 2004/07/12 08:02:55 sturnus ++// accelerating snipe setting: don't get snipe key, it's done again later anyway ++// ++// Revision 1.1.2.3 2004/06/25 14:22:02 sturnus ++// finished remote control via ~/.bidwatcher/item.add ++// ++// Revision 1.1.2.2 2004/06/10 16:31:08 sturnus ++// continued work on commando file parser ++// ++// Revision 1.1.2.1 2004/06/10 09:02:08 sturnus ++// files for bidgroups and extensions ++// ++// Revision 1.14 2004/06/03 12:52:03 js02 ++// *** empty log message *** ++// ++// Revision 1.13 2004/06/03 12:50:19 js02 ++// add items from ~/.bidwatcher/item.add ++// ++// Revision 1.12 2004/05/28 06:50:56 js02 ++// failed getkeys are stored ++// ++// Revision 1.11 2004/05/25 15:14:34 js02 ++// Bugfix: wrong parameter type for call to delBidGroupItem ++// ++// Revision 1.10 2004/05/19 08:46:52 js02 ++// Bugfixes ++// ++// Revision 1.9 2004/05/18 14:45:19 js02 ++// *** empty log message *** ++// ++// Revision 1.8 2004/05/18 14:36:20 js02 ++// copying of snipe data at creation ++// ++// Revision 1.7 2004/05/18 14:10:33 js02 ++// Bidgroups work ++// ++// Revision 1.6 2004/05/18 13:29:50 js02 ++// integration continued ++// ++// Revision 1.5 2004/05/17 23:33:33 js02 ++// bid groups continued ++// ++// Revision 1.3 2004/05/15 13:12:24 js02 ++// rebuild function: do not depend on global variables anymore ++// ++// Revision 1.2 2004/05/14 16:30:39 js02 ++// bidgroup control via middle mouse button implemented ++// ++// Revision 1.1 2004/05/13 21:54:57 js02 ++// View and Control for Bidgroups ++// ++ ++#include ++#include ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include "bidgui.h" ++ ++using namespace std; ++ ++// Replaces or removes ascii characters > 127. On some system they are not properly shown. ++void removeAscii127(char *info) ++{ ++ unsigned char *p = (unsigned char*)info; ++ while(*p) { ++ switch(*p) { ++ case (unsigned char)'ä': ++ *p = 'a'; ++ break; ++ ++ case (unsigned char)'ö': ++ *p = 'o'; ++ break; ++ ++ case (unsigned char)'ü': ++ *p = 'u'; ++ break; ++ ++ case (unsigned char)'Ä': ++ *p = 'A'; ++ break; ++ ++ case (unsigned char)'Ö': ++ *p = 'O'; ++ break; ++ ++ case (unsigned char)'Ü': ++ *p = 'u'; ++ break; ++ ++ case (unsigned char)'ß': ++ *p = 's'; ++ break; ++ } ++ ++ if(*p > 127) *p = ' '; ++ ++ p++; ++ } ++} ++ ++BidGroup *getBidGroup() ++{ ++ static BidGroup bid_group; ++ return &bid_group; ++} ++ ++static bool hasBid(struct auctioninfo *auc) ++{ ++ if(auc->isSnipe) return true; ++ if(auc->snipeAmount > 0) return true; ++ if(auc->myBidAmount > 0) return true; ++ return false; ++} ++ ++static void copySnipe(struct auctioninfo *dst, const struct auctioninfo *src) ++{ ++ setBid(dst, src->myBidAmount, src->myBidQuantity, true); ++} ++ ++// set/change bidgroup for an item ++void switchBidGroup(struct auctioninfo *auction[], int auc_num, int current_auc, int new_auc, ++ const char *subdir, int time_diff, const char *auth_id) ++{ ++ if(current_auc < 0 || current_auc >= auc_num) return; ++ if(new_auc < 0 || new_auc >= auc_num) return; ++ BidGroup *group = getBidGroup(); ++ struct auctioninfo *cauc = auction[current_auc]; ++ struct auctioninfo *auc = auction[new_auc]; ++ BidGroup::IdType cid = cauc->ItemNumber; ++ BidGroup::IdType id = auc->ItemNumber; ++ int cgid = group->groupId(cid); ++// int gid = group->groupId(id); ++ ++ if(cgid >= 0) group->delItem(id); ++ group->addItem(cid, id); ++ group->sweepList(); ++ if(hasBid(cauc) && !hasBid(auc)) copySnipe(auc, cauc); ++ if(!hasBid(cauc) && hasBid(auc)) copySnipe(cauc, auc); ++ ++ setBidGroupAuction(auction, auc_num, auth_id); ++ UpdateList(); ++ WriteAucFile(); ++} ++ ++char *configFileName(char *file, const char *subdir, const char *fname) ++{ ++ sprintf(file, "%s/%s/%s", getenv("HOME"), subdir, fname); ++ return file; ++} ++ ++char *bidGroupFile(char *file, const char *subdir) ++{ ++ return configFileName(file, subdir, "bidgroup.cfg"); ++} ++ ++void writeBidGroup(const char *subdir) ++{ ++ char file[200]; ++ BidGroup *group = getBidGroup(); ++ group->write(bidGroupFile(file, subdir)); ++} ++ ++void readBidGroup(const char *subdir) ++{ ++ char file[200]; ++ BidGroup *group = getBidGroup(); ++ group->clear(); ++ group->read(bidGroupFile(file, subdir)); ++} ++ ++void bidGroupComment(char **str, struct auctioninfo *auction[], int auc) ++{ ++ BidGroup *group = getBidGroup(); ++ const int gid = group->groupId(auction[auc]->ItemNumber); ++ if(group->numGroup() > 0) { ++ if(gid >= 0) *str = g_strdup_printf(" %*s%d%*s: %s", gid, "", gid + 1, group->numGroup() - gid - 1, "", *str); ++ else *str = g_strdup_printf(" %*s : %s", group->numGroup() - 1, "", *str); ++ } ++} ++ ++SetBidGroupAuction::~SetBidGroupAuction() ++{ ++ setBidGroupAuction(auction, auc_num, auth_id); ++} ++ ++// mark all items in a successful bidgroup ++static void findSucceededAuc(map &succeeded, const BidGroup::ItemList *list) ++{ ++ if(!list) return; ++ ++ bool any_succeeded = false; ++ for(BidGroup::ItemList::const_iterator it = list->begin(); it != list->end(); ++it) { ++ if(succeeded[*it]) { ++ any_succeeded = true; ++ break; ++ } ++ } ++ ++ if(any_succeeded) { ++ for(BidGroup::ItemList::const_iterator it = list->begin(); it != list->end(); ++it) { ++ succeeded[*it] = any_succeeded; ++ } ++ } ++} ++ ++// I won this auction. ++static bool isMine(struct auctioninfo *auction, const char *auth_id) ++{ ++ return strcmp(auction->HighBidder, auth_id) == 0 && auction->UpdTime >= auction->EndsValue; ++} ++ ++void setBidGroupAuction(struct auctioninfo *auction[], int auc_num, const char *auth_id) ++{ ++ BidGroup *group = getBidGroup(); ++ map succeeded; ++ ++ for(int i = 0; i < auc_num; i++) { ++ struct auctioninfo *a = auction[i]; ++ succeeded[a->ItemNumber] = isMine(a, auth_id); ++ } ++ ++ for(int i = 0; i < group->numGroup(); i++) { ++ findSucceededAuc(succeeded, group->getGroup(i)); ++ } ++ ++ for(int i = 0; i < auc_num; i++) { ++ struct auctioninfo *a = auction[i]; ++ if(a->isSnipe && !isMine(a, auth_id) && succeeded[a->ItemNumber]) { ++ printf("clear snipe %llu\n", a->ItemNumber); ++ ClearSnipe(i); ++ } ++ } ++} ++ ++void delBidGroupItem(struct auctioninfo *auction[], int auc) ++{ ++ BidGroup *group = getBidGroup(); ++ group->delItem(auction[auc]->ItemNumber); ++ group->sweepList(); ++} ++ ++// save something in a file defined by format ++void savePage(const char *page, const char *format, ...) ++{ ++ va_list va; ++ va_start(va, format); ++ char fname[4096]; ++ vsprintf(fname, format, va); ++ va_end(va); ++ FILE *fp = fopen(fname, "w"); ++ if(fp) { ++ fprintf(fp, "%s", page); ++ fclose(fp); ++ } ++} ++ ++// set up a bid or snipe ++void setBid(struct auctioninfo *auction, float bid, int quantity, bool snipe) ++{ ++ if(!auction) return; ++ ++ auction->isSnipe = snipe; ++ auction->isPreBid = snipe; ++ auction->myBidAmount = bid; ++ auction->myBidQuantity = quantity; ++ memset(auction->snipeKey, 0, sizeof(auction->snipeKey)); ++ ++ if(snipe) { ++ auction->snipeAmount = bid; ++ auction->snipeQty = quantity; ++ } else { ++ auction->snipeAmount = 0; ++ auction->snipeQty = 0; ++ auction->getkey(bid, quantity); ++ if(auction->snipeKey[0]) auction->bid(FALSE); ++ } ++ ++ UpdateList(); ++} ++ ++// set up a bid or snipe reading amount + quantity from a file ++static struct auctioninfo *setBid(struct auctioninfo *auction, FILE *fp, bool snipe) ++{ ++ if(!auction) return auction; ++ float bid; ++ int qty; ++ if(fscanf(fp, "%f%d", &bid, &qty) != 2) return auction; ++ setBid(auction, bid, qty, snipe); ++ fprintf(stderr, "%s %llu bid: %f qty: %d\n", snipe ? "snipeing" : "bidding ", auction->ItemNumber, bid, qty); ++ return auction; ++} ++ ++/* ++ * Adds items from the file "~/.bidwatcher/item.add" to bidwatcher. ++ * Places bids/snipes if required. ++ * ++ * Syntax: a continuous stream of the following command ++ * "ebay-id" adds an item ++ * "add ebay-id" adds an item ++ * "bid ebay-id amount quantity" bids for an item ++ * "snipe ebay-id amount quantity" snipes for an item ++ * ++ * Example: ++ * 568880089 ++ * add 568880010 ++ * bid 568888888 10.51 1 ++ * snipe 568888777 12.11 1 ++ * ++ * I use this to remotely control my bidwatcher via email-filters. ++ */ ++void addItemsFromFile(const char *subdir, volatile bool &up_in_prog) ++{ ++ class AutoFp { ++ FILE *fp; ++ ++ public: ++ AutoFp(FILE *fp): fp(fp) { ++ if(!fp) return; ++ flock(fileno(fp), LOCK_EX); ++ } ++ ++ ~AutoFp() { ++ if(!fp) return; ++ flock(fileno(fp), LOCK_UN); ++ fclose(fp); ++ } ++ ++ operator FILE*() const { return fp; } ++ FILE* operator->() const { return fp; } ++ }; ++ ++ class AutoFlag { ++ volatile bool &up_in_prog; ++ ++ public: ++ AutoFlag(volatile bool &up_in_prog): up_in_prog(up_in_prog) { up_in_prog = true; } ++ ~AutoFlag() { up_in_prog = false;} ++ }; ++ ++ if(up_in_prog) return; ++ AutoFlag a_flag(up_in_prog); ++ ++ if(timeToNextEnd() < 5 * 60) return; ++ ++ char file[256]; ++ configFileName(file, subdir, "item.add"); ++ AutoFp fp(fopen(file, "r+")); ++ if(!fp) return; ++ char buffer1[20]; ++ char buffer2[20]; ++ char *rd = buffer1; ++ char *act = buffer2; ++ const char *def_action = "add"; ++ strcpy(act, def_action); ++ ++ while(fscanf(fp, "%19s", rd) == 1) { ++ if(timeToNextEnd() < 5 * 60) return; ++ unsigned long long id; ++ ++ if(sscanf(rd, "%llu", &id) != 1) { ++ swap(rd, act); ++ continue; ++ } ++ ++ up_in_prog = false; ++ if(strcmp(act, "add") == 0) { ++ fprintf(stderr, "adding %llu\n", id); ++ addNewItem(id); ++ } else if(strcmp(act, "bid") == 0) { ++ setBid(addNewItem(id), fp, false); ++ } else if(strcmp(act, "snipe") == 0) { ++ setBid(addNewItem(id), fp, true); ++ } else { ++ fprintf(stderr, "ignoring %s %llu\n", act, id); ++ } ++ up_in_prog = true; ++ ++ strcpy(act, def_action); ++ } ++ ftruncate(fileno(fp), 0); ++} ++ +diff -u -ruN -b -B -w /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidgui.h anoncvs-STABLE_1_3/bidgui.h +--- /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidgui.h Wed Dec 31 16:00:00 1969 ++++ bidgui.h Fri Jun 25 07:22:02 2004 +@@ -0,0 +1,90 @@ ++ ++/* ++ * Copyright (C) 2004 Planet Intelligent Systems GmbH ++ * Residence Park 1-7, 19065 Raben Steinfeld, Germany, Europe, Earth ++ * All rights reserved ++ * ++ * Author: Jan Starzynski ++ * ++ * $Id: bidgui.h,v 1.1.2.2 2004/06/25 14:22:02 sturnus Exp $ ++ * ++ * $Log: bidgui.h,v $ ++ * Revision 1.1.2.2 2004/06/25 14:22:02 sturnus ++ * finished remote control via ~/.bidwatcher/item.add ++ * ++ * Revision 1.1.2.1 2004/06/10 09:02:09 sturnus ++ * files for bidgroups and extensions ++ * ++ * Revision 1.9 2004/06/03 12:50:19 js02 ++ * add items from ~/.bidwatcher/item.add ++ * ++ * Revision 1.8 2004/05/28 06:50:56 js02 ++ * failed getkeys are stored ++ * ++ * Revision 1.7 2004/05/25 15:14:34 js02 ++ * Bugfix: wrong parameter type for call to delBidGroupItem ++ * ++ * Revision 1.6 2004/05/18 14:45:19 js02 ++ * *** empty log message *** ++ * ++ * Revision 1.5 2004/05/18 13:29:50 js02 ++ * integration continued ++ * ++ * Revision 1.4 2004/05/17 23:33:33 js02 ++ * bid groups continued ++ * ++ * Revision 1.3 2004/05/15 13:12:24 js02 ++ * rebuild function: do not depend on global variables anymore ++ * ++ * Revision 1.2 2004/05/14 16:30:39 js02 ++ * bidgroup control via middle mouse button implemented ++ * ++ * Revision 1.1 2004/05/13 21:54:57 js02 ++ * View and Control for Bidgroups ++ * ++ */ ++ ++#ifndef BIDWATCHER_BIDGUI_H ++#define BIDWATCHER_BIDGUI_H ++ ++#include ++#include ++#include ++ ++#include "bidwatcher.h" ++#include "bidgroup.h" ++ ++class SetBidGroupAuction { ++ struct auctioninfo **auction; ++ int auc_num; ++ int ebay_offset; ++ const char *auth_id; ++public: ++ SetBidGroupAuction(struct auctioninfo *auction[], int auc_num, int ebay_offset, const char *auth_id): ++ auction(auction), ++ auc_num(auc_num), ++ ebay_offset(ebay_offset), ++ auth_id(auth_id) ++ {} ++ ++ ~SetBidGroupAuction(); ++}; ++ ++void removeAscii127(char *info); ++ ++BidGroup *getBidGroup(); ++void switchBidGroup(struct auctioninfo *auction[], int auc_num, int current_auc, int new_auc, ++ const char *subdir, int time_diff, const char *auth_id); ++void delBidGroupItem(struct auctioninfo *auction[], int auc); ++char *configFileName(char *file, const char *subdir, const char *fname); ++char *bidGroupFile(char *file, const char *subdir); ++void writeBidGroup(const char *subdir); ++void readBidGroup(const char *subdir); ++void bidGroupComment(char **str, struct auctioninfo *auction[], int auc); ++void setBidGroupAuction(struct auctioninfo *auction[], int auc_num, const char *auth_id); ++void savePage(const char *page, const char *format, ...); ++void addItemsFromFile(const char *subdir, volatile bool &up_in_prog); ++void setBid(struct auctioninfo *auction, float bid, int quantity, bool snipe); ++ ++#endif ++ +diff -u -ruN -b -B -w /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidwatcher.cpp anoncvs-STABLE_1_3/bidwatcher.cpp +--- /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidwatcher.cpp Fri Apr 23 13:23:28 2004 ++++ bidwatcher.cpp Tue Aug 3 08:34:27 2004 +@@ -63,6 +63,8 @@ + #include + + #include "bidwatcher.h" ++#include "bidgroup.h" ++#include "bidgui.h" + + #include "pixmaps/user.xpm" + #include "pixmaps/clock.xpm" +@@ -223,19 +225,12 @@ + */ + + +- if (auc->myBidQuantity!=0) { +- if (!strcmp(auc->HighBidder, authID)) +- return (i%2)?clist_win2:clist_win1; +- +- else if ((auc->isSnipe && auc->myBidAmount > auc->CurrentBid) || +- (auc->isSnipe && auc->BidCount == 0 && +- auc->myBidAmount >= auc->CurrentBid)) +- return (i%2)?clist_willwin2:clist_willwin1; ++ if (auc->myBidQuantity > 0) { ++ if (!strcmp(auc->HighBidder, authID)) return (i % 2) ? clist_win2 : clist_win1; ++ if ((auc->isSnipe && auc->myBidAmount > auc->minBid())) return (i % 2) ? clist_willwin2 : clist_willwin1; ++ } + +- else + return (i%2)?clist_lose2:clist_lose1; +- +- } else return (i%2)?clist_lose2:clist_lose1; + } + + void checkaucs(int line) { +@@ -786,19 +781,16 @@ + gtk_widget_set_sensitive(obj->okbutton, FALSE); + gtk_widget_set_sensitive(obj->cancelbutton, FALSE); + gtk_label_set_text(GTK_LABEL(obj->currentbidlabel), "Obtaining key..."); +- obj->myauc->getkey(atof(gtk_entry_get_text(GTK_ENTRY(obj->bidtext))), +- atoi(gtk_entry_get_text(GTK_ENTRY(obj->quantitytext)))); ++ setBid(obj->myauc, ++ atof(gtk_entry_get_text(GTK_ENTRY(obj->bidtext))), ++ atoi(gtk_entry_get_text(GTK_ENTRY(obj->quantitytext))), ++ doSnipe ++ ); + gtk_widget_set_sensitive(obj->okbutton, TRUE); + gtk_widget_set_sensitive(obj->cancelbutton, TRUE); + gtk_label_set_text(GTK_LABEL(obj->currentbidlabel), ""); + +- // Don't do any bidding if the key setup failed +- if (obj->myauc->snipeKey[0] == '\0') return; +- + if (doSnipe) { +- obj->myauc->snipeAmount=atof(gtk_entry_get_text(GTK_ENTRY(obj->bidtext))); +- obj->myauc->snipeQty=atoi(gtk_entry_get_text(GTK_ENTRY(obj->quantitytext))); +- obj->myauc->isSnipe = TRUE; + gtk_widget_set_sensitive(obj->okbutton, TRUE); + gtk_widget_set_sensitive(obj->cancelbutton, TRUE); + gtk_label_set_text(GTK_LABEL(obj->currentbidlabel), ""); +@@ -806,6 +798,8 @@ + return; + } + else { ++ // Don't do any bidding if the key setup failed ++ if (obj->myauc->snipeKey[0] == '\0') return; + gtk_label_set_text(GTK_LABEL(obj->currentbidlabel), "Submitting bid..."); + // now, finalize bid with the key obtained. + char WebPage[255]; +@@ -880,7 +874,7 @@ + + } + +-static int find_auction_index(unsigned long long aucnum) ++int find_auction_index(unsigned long long aucnum) + { + // Locate the auction in the array of auctions + for(int i=0; iItemNumber); + } + ++struct auctioninfo *find_auction(unsigned long long aucnum) ++{ ++ int idx = find_auction_index(aucnum); ++ if(idx < 0) return NULL; ++ return auction[idx]; ++} ++ + void commentok_callback(GtkWidget *widget, gpointer data) + { + // Set the comment text into the auction struct +@@ -1832,12 +1833,7 @@ + if (myauc->snipeQty >= 2) // DBS + strcpy(unitstring, " units at "); // DBS + +- if (myauc->BidCount == 0 && !TYPE_EBAYMOTORSCAR) +- sprintf(temp, "%.2f", myauc->FirstBid); +- else { +- sprintf(temp,"%.2f", +- calculateBidIncrement(myauc->CurrentBid, myauc->currency)); +- } ++ sprintf(temp, "%.2f", myauc->minBid()); + + char *quant, *bidc; + strcpy(info, " "); +@@ -1924,6 +1920,7 @@ + gtk_widget_set_sensitive(bidderbutton, !strcasecmp(authID, myauc->Seller)); + */ + ++ removeAscii127(info); + gtk_label_set_text(GTK_LABEL(infolabel), info); + + /* gtk_widget_set_sensitive(sellerbutton, FALSE); +@@ -2029,15 +2026,7 @@ + gtk_widget_show(currentbidlabel); + gtk_widget_show(timeleftlabel); + +- chTemp[0]=0; +- // int skipchars=strcspn(myauc->FirstBid, "0123456789"); +- if (myauc->BidCount == 0) +- sprintf(chTemp, "%.2f", myauc->FirstBid); +- else { +- sprintf(chTemp, "%.2f", +- calculateBidIncrement(myauc->CurrentBid, myauc->currency)); +- } +- ++ sprintf(chTemp, "%.2f", myauc->minBid()); + bidlabel = gtk_label_new("Your MAXIMUM bid"); + bidtext = gtk_entry_new(); + gtk_entry_set_text(GTK_ENTRY(bidtext), chTemp); +@@ -2381,6 +2370,7 @@ + gtk_clist_get_selection_info(GTK_CLIST(w), (gint) event->x, + (gint) event->y, &row, &col); + ++ if(event->button == 2) switchBidGroup(auction, aucIdx, currentauc, row, bw_subdir, timeDiff, authID); // always call before setting currentauc + currentauc = row; + + if (aucIdx != 0) { +@@ -2867,6 +2858,8 @@ + fprintf(file, " endauction\n"); + } + fclose(file); ++ ++ writeBidGroup(bw_subdir); + } + + BidWindow::~BidWindow() { +@@ -3002,6 +2995,7 @@ + void ClearSnipe(int choice) + { + auction[choice]->isSnipe = FALSE; ++ auction[choice]->isPreBid = FALSE; + strcpy(auction[choice]->snipeKey, ""); + auction[choice]->snipeAmount=0; + auction[choice]->snipeQty=0; +@@ -3291,7 +3285,7 @@ + // calls: + // UpdateAuction(), DeleteAuction(), UpdateList() + ////////////////////////////////////////////////////////////////////////////// +-void addNewItem(unsigned long long newNumber) ++struct auctioninfo *addNewItem(unsigned long long newNumber) + { + updateInProgress = TRUE; + int i; +@@ -3301,7 +3295,7 @@ + // over the limit on auctions already + showError("You already have the maximum allowed auctions." ); + updateInProgress = FALSE; +- return; ++ return NULL; + } + + // scan current list, make sure this isn't a dup +@@ -3318,9 +3312,9 @@ + // caller would have to duplicate this loop if he did not want to take + // the chance of the user seeing an "error" message. + DPRINTF(DLOW, ("The auction %llu is already in the list.\n", auction[i]->ItemNumber)); +- showStatus(" adding auction..."); ++ showStatus(""); + updateInProgress = FALSE; +- return; ++ return auction[i]; + } + } + +@@ -3343,7 +3337,7 @@ + updateInProgress = FALSE; + updatelist_callback(NULL); + WriteAucFile(); +- return; ++ return NewAuction; + } + else if (returnVal == INFO_BADAUCTION) { + char msg[100]; +@@ -3357,6 +3351,7 @@ + + updateInProgress = FALSE; + showStatus(""); ++ return NULL; + } + ////////////////////////////////////////////////////////////////////////////// + // timer1Up: +@@ -3383,6 +3378,8 @@ + + gint secondticker_callback(gpointer data) // second ticker + { ++ addItemsFromFile(bw_subdir, updateInProgress); ++ + static volatile int checking_snipes = FALSE; + + if (clockIsSet) { +@@ -3422,12 +3419,20 @@ + if (auction[i]->isSnipe) { + timeLeft = CalcTimeLeft(auction[i]->EndsValue, timeDiff); + +- if (!checking_snipes) { ++ if (!checking_snipes && timeLeft > -30) { + checking_snipes = TRUE; + ++ if(timeLeft < cur_snipe_delay + 60) { ++ if(auction[i]->isPreBid) { ++ auction[i]->isPreBid = FALSE; ++ auction[i]->getkey(auction[i]->snipeAmount, ++ auction[i]->snipeQty); ++ } ++ } ++ + if (timeLeft < cur_snipe_delay) { + auction[i]->isSnipe = FALSE; +- DoSnipe(i); ++ if(auction[i]->snipeKey[0]) DoSnipe(i); + } + + checking_snipes = FALSE; +@@ -3613,6 +3618,23 @@ + gtk_timeout_add(time_to_next_update,updatelist_callback,NULL); + return FALSE; + } ++ ++static void setProxyURL(char *proxystring, char *proxyuserstring, char *proxypassstring) ++{ ++ if (proxyurl != NULL) { ++ delete(proxyurl); ++ proxyurl = NULL; ++ } ++ ++ if (strlen(proxystring) > 2) { ++ char *pxy = g_strdup_printf("http://%s/", proxystring); ++ proxyurl = new URL(pxy, NULL, proxyuserstring, proxypassstring); ++ g_free(pxy); ++ } else { ++ proxyurl = NULL; ++ } ++} ++ + ////////////////////////////////////////////////////////////////////////////// + // ReadAucFile: + // called once at startup, reads the username and stored auctions from +@@ -3829,6 +3851,7 @@ + memset(authPASS, 0, sizeof(authPASS)); + } + else if (!strcasecmp(keyword, "auction")) { ++ setProxyURL(proxystring, proxyuserstring, proxypassstring); + char which[20]; + auction[aucIdx] = new auctioninfo(); + fscanf(file, "%llu", &auction[aucIdx]->ItemNumber); +@@ -3866,9 +3889,11 @@ + auction[aucIdx]->snipeAmount, + auction[aucIdx]->snipeQty); + #endif +- auction[aucIdx]->isSnipe = 1; +- auction[aucIdx]->getkey(auction[aucIdx]->snipeAmount, +- auction[aucIdx]->snipeQty); ++ ++ setBid(auction[aucIdx], ++ auction[aucIdx]->snipeAmount, ++ auction[aucIdx]->snipeQty, ++ true); + + } + else if (!strcasecmp(which, "endauction")) +@@ -3879,22 +3904,13 @@ + } + fclose(file); + +- if (proxyurl != NULL) { +- delete(proxyurl); +- proxyurl = NULL; +- } +- if (strlen(proxystring) > 2) { +- char *pxy = g_strdup_printf("http://%s/", proxystring); +- proxyurl = new URL(pxy, NULL, proxyuserstring, +- proxypassstring); +- g_free(pxy); +- } +- else proxyurl = NULL; +- ++ setProxyURL(proxystring, proxyuserstring, proxypassstring); + resetTimeSyncURL(); + + makeStyles(); + resetStyles(); ++ ++ readBidGroup(bw_subdir); + } + + ////////////////////////////////////////////////////////////////////////////// +@@ -3938,6 +3954,8 @@ + auction[i]->Comments, + auction[i]->Seller}; + ++ bidGroupComment(&item[5], auction, i); ++ + int j; + for(j=0; j= aucIdx) return; // we are out of range ++ delBidGroupItem(auction, index); + // Loop through AucNumList, moving list up to fill the gap + // where choice will be removed, this should be a linked list. + WriteLog(index); +@@ -4172,6 +4191,8 @@ + // the item number out of the URL. because it is possible that there are CRLF + // in the URL, strip them out first and call addNewItem() with the auction + // number. ++ strip_crlf(Buff); ++ + char *pszendurl; + char *pszonlyurl; + char *pszitemnumber; +@@ -4184,12 +4205,12 @@ + memset(pszonlyurl, 0, pszendurl - pszitemurl + 1); + memcpy(pszonlyurl, pszitemurl, pszendurl - pszitemurl); + pszitemnumber = strstr(pszonlyurl, "item="); +- // save some time and only strip crlf from the item number +- strip_crlf(pszitemnumber); +- if(pszitemnumber) ++ if(pszitemnumber) { + // addNewItem() checks for dups and for maximum number of auctions. + // no need to do it twice. +- addNewItem(atoul(pszitemnumber + 5)); ++ unsigned long long item; ++ if(sscanf(pszitemnumber + 5, "%llu", &item) == 1) addNewItem(item); ++ } + // delete the new'd memory + delete pszonlyurl; + // get the next url starting from the end of the current url. +@@ -4205,6 +4226,8 @@ + /////////////////////////////////////////////////////////////////// + void UpdateList() + { ++ if(!aucList) return; ++ + CHECK; + char chTemp[20]; + ArrangeList(); +@@ -4248,6 +4271,8 @@ + auction[i]->Comments, + auction[i]->Seller}; + ++ bidGroupComment(&item[5], auction, i); ++ + gtk_clist_insert(GTK_CLIST(aucList), i, item); + if (auction[i]->isSnipe) { + gtk_clist_set_pixtext(GTK_CLIST(aucList), i, 0, item[0], 5, +@@ -4326,6 +4351,8 @@ + int auctioninfo::getinfo() + { + CHECK; ++ SetBidGroupAuction set_bid_group(auction, aucIdx, timeDiff, authID); ++ + int returnVal; + char *HtmlBuff; + char *urlstring; +@@ -4417,6 +4444,7 @@ + } + } + free(Buff); ++ UpdTime = time(NULL) + timeDiff; + return INFO_SUCCESS; + } + free(Buff); +@@ -4983,6 +5011,7 @@ + memset(this, 0, sizeof(auctioninfo)); + magic = 12345; + isEndless = 0; ++ UpdTime = 0; + } + + auctioninfo::~auctioninfo() { +diff -u -ruN -b -B -w /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidwatcher.h anoncvs-STABLE_1_3/bidwatcher.h +--- /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/bidwatcher.h Mon Apr 19 20:14:09 2004 ++++ bidwatcher.h Tue Aug 3 08:34:27 2004 +@@ -94,6 +94,7 @@ + gint secondticker_callback(gpointer data); + gint bigdelay_callback(gpointer data); + gint updatelist_callback(gpointer data); ++float calculateBidIncrement(float currentBid, const char *currency); + + // other constants + #define HUGEBUFF (256*1024) +@@ -161,15 +162,16 @@ + float myBidAmount; /* Our bid */ + int myBidQuantity; /* Our bid quantity for dutch */ + long int EndsValue; /* time auction ends in seconds */ ++ long int UpdTime; /* time of last update */ + char stat; /* status of auction for GUI */ + char bidstatus; /* final status of bid/snipe */ + char reserveMet; /* [y/n/x] = Status of reserve */ + bool isSnipe; /* Is this a snipe or not? */ ++ bool isPreBid; /* Needs pre-bid for snipe */ + int AuctionType; /* Type: ebay/ebaymotors/etc. */ + URL *infourl; /* URL for auction info */ + URL *bidurl; /* URL for bidding/sniping */ + int magic; /* Used to detect corrupt lists */ +- int bid(bool); + int isEndless; /* For non-auction auctions */ + + auctioninfo(); +@@ -177,6 +179,10 @@ + int getinfo(); + bool parseaucinfo(const char *); + void getkey(float bid, int quantity); ++ int bid(bool); ++ ++ double currentPrize() const { return BidCount > 0 ? CurrentBid : FirstBid; } ++ double minBid() const { return BidCount > 0 ? calculateBidIncrement(CurrentBid, currency) : FirstBid; } + }; + + typedef char string30[30]; +@@ -196,7 +202,7 @@ + void CmExit(); + void CmCancelClicked(); + void doubleClick(int); +-void addNewItem(unsigned long long); ++struct auctioninfo *addNewItem(unsigned long long); + void timer1Up(); + void timer2Up(); + void timer3Up(); +@@ -360,7 +366,6 @@ + ~ConfirmWindow(); + }; + +-float calculateBidIncrement(float currentBid, char *currency); + char *StripHtmlTags(const char *stringToStrip); + char *StripAndTab(const char *stringToStrip); + int ProcessBidSubmission(char *Buff, char *lineBuff, int lineBuffLen); +@@ -400,6 +405,10 @@ + void basic_authentication_encode (const char *user, + const char *passwd, + char **encstr); ++ ++int find_auction_index(unsigned long long aucnum); ++int find_auction_index(struct auctioninfo *auc); ++struct auctioninfo *find_auction(unsigned long long aucnum); + + extern bool cancelPressed; + +diff -u -ruN -b -B -w /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/daemon.c anoncvs-STABLE_1_3/daemon.c +--- /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/daemon.c Wed Dec 31 16:00:00 1969 ++++ daemon.c Tue Apr 2 13:58:06 2002 +@@ -0,0 +1,266 @@ ++/* daemon.c ++ * Main code for the biddaemon software. ++ * Hey you with your bug report ready, DO NOT EXPECT THIS TO WORK YET. ++ * ;) -kdwyer ++ */ ++ ++/* bidwatcher ++ copyright (c) 1999, 2000, 2001, 2002 ++ Trent McNair (trent@rmci.net) ++ Tom McNair (tmcnair@cyberhighway.net) ++ Wayne Schlitt (wayne@midwestcs.com) ++ Ben Byer (bushing@users.sourceforge.net) ++ Kevin Dwyer (kevin@pheared.net) ++ ++ use of this code is restricted to the terms ++ of the GNU GPL, which should have been included in this ++ distribution. If not, see www.gnu.org/copyleft/gpl.html. ++ Here is the short version: ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 2 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. ++*/ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "daemon.h" ++ ++#define MAXMSG sizeof(struct bidmessage) ++#define MAXCLIENTS 100 ++ ++typedef struct { ++ int sd; ++ char inbuf[MAXMSG]; ++ char outbuf[MAXMSG]; ++ struct sockaddr_in addr; ++ int closed; ++ int pending; ++ int welcome; ++} users; ++ ++/*typedef struct users U;*/ ++ ++typedef void (*sighandler_t)(int); ++ ++int write_pending(users *); ++int read_pending(users *); ++int parse_input(users); ++sighandler_t got_sig(int); ++ ++int main (int argc, char *argv[]) ++{ ++ int sd=0, ret=0, len=0, i=0, stoploop=0; ++ char *port="4221"; ++ ++ users c[MAXCLIENTS]; ++ ++ struct sockaddr_in sin; ++ struct sockaddr_in sintmp; ++ ++ signal(SIGINT, got_sig(sd)); ++ ++ memset(&sin,0,sizeof(sin)); ++ memset(&sin,0,sizeof(sintmp)); ++ memset(&c,0,sizeof(c)); ++ ++ /* setting up our daemon, sin_port = port to listen on ++ and sin_addr.saddr is source address to listen on. ++ */ ++ ++ sin.sin_family = AF_INET; ++ sin.sin_port = htons(atoi(port)); ++ /* Listen on all addresses */ ++ sin.sin_addr.s_addr = inet_addr("0.0.0.0"); ++ ++ /* procedure is socket, bind, listen, accept in loop. */ ++ ++ sd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); ++ ++ ret = bind(sd, (struct sockaddr *)&sin, sizeof(sin)); ++ ++ if (ret == -1) { ++ perror("bind()"); ++ exit(0); ++ } ++ ++ ret = listen(sd, 5); ++ ++ if (ret == -1) { ++ perror("listen()"); ++ exit(0); ++ } ++ ++ ret = fcntl(sd, F_SETFL, O_NONBLOCK); ++ ++ if (ret == -1) { ++ perror("fcntl()"); ++ exit(0); ++ } ++ ++ while (!stoploop) { ++ len = sizeof(c[i].addr); ++ ret = accept(sd, (struct sockaddr *)&c[i].addr, &len); ++ if (ret != -1) { ++ c[i].sd = ret; ++ c[i].pending = 1; ++ c[i].closed = 0; ++ ++ /* Should make this quieter later. */ ++ write(c[i].sd, "biddaemon v1.0\n", 15); ++ ++ printf("accept():Got connect from %s source port %i\n", ++ inet_ntoa(c[i].addr.sin_addr), ++ ntohs(c[i].addr.sin_port)); ++ ++ ret = fcntl(c[i].sd, F_SETFL, O_NONBLOCK); ++ ++ if (ret == -1) { ++ perror("fcntl()"); ++ exit(0); ++ } ++ ++ printf("i=%i/sd=%i/pend=%i/closed=%i\n", i,c[i].sd,c[i].pending,c[i].closed); ++ i++; ++ } ++ ++ ++ write_pending(c); ++ ++ read_pending(c); ++ ++ usleep(1); ++ ++ } ++ ++ return 0; ++} ++ ++int write_pending(users c[MAXCLIENTS]) ++{ ++ int i=0,ret=0; ++ ++ while (i < MAXCLIENTS) { ++ if (c[i].pending == 1) { ++ if (ret == -1) { ++ perror("write()"); ++ close(c[i].sd); ++ c[i].closed = 1; ++ } ++ ++ if (strlen(c[i].outbuf) > 0) { ++ ret = write(c[i].sd, c[i].outbuf, strlen(c[i].outbuf)); ++ ++ if (ret == -1) { ++ perror("write()"); ++ close(c[i].sd); ++ c[i].closed = 1; ++ c[i].sd = -1; ++ } ++ ++ memset(&c[i].outbuf, 0, sizeof(c[i].outbuf)); ++ } ++ ++ c[i].pending = 0; ++ ++ } ++ ++ i = i + 1; ++ ++ } ++ return 0; ++} ++ ++int parse_input(users c) ++{ ++ struct bidmessage bm; ++ ++ printf("DEBUG: Parsing a message\n"); ++ ++ memset(&bm, 0, sizeof(bm)); ++ memcpy(&bm, c.inbuf, sizeof(bm)); ++ ++ if (bm.type == 0) { ++ printf("Got 0\n"); ++ return MSG_PING; ++ } ++ if (bm.type == 1) ++ return MSG_ADD; ++} ++ ++int read_pending(users c[MAXCLIENTS]) ++{ ++ int i=0, ret=0, x=0; ++ /* char inbuf[MAXMSG];*/ ++ ++ while(i < MAXCLIENTS) { ++ if (c[i].sd > 0) { ++ ret = read(c[i].sd, c[i].inbuf, sizeof(c[i].inbuf)); ++ ++ if (ret >= 0) { ++ printf("%s --- %i bytes \n", c[i].inbuf, ret); ++ ++ switch(parse_input(c[i])) { ++ case MSG_DETACH: ++ printf("Closing sd %i!\n", i); ++ write(c[i].sd,"Closing connection...\n",22); ++ close(c[i].sd); ++ c[i].closed = 1; ++ c[i].sd = -1; ++ break; ++ case MSG_ADD: ++ printf("got add on sd %i\n", i); ++ break; ++ } ++ } ++ else { ++ if (errno != EAGAIN) { ++ perror("write()"); ++ close(c[i].sd); ++ c[i].closed = 1; ++ c[i].sd = -1; ++ } ++ } ++ memset(&c[i].inbuf,0,sizeof(c[i].inbuf)); ++ } ++ i++; ++ } ++ return 0; ++} ++ ++sighandler_t got_sig(int sd) ++{ ++ // This is broken right now. ++ // printf("Got Signal !\n"); ++ ++ // if (i == SIGINT) ++ //{ ++ // printf("Shutting down daemon! %i\n", sd); ++ // close(sd); ++ // } ++ ++ return 0; ++} ++ ++ ++ ++ ++ ++ +diff -u -ruN -b -B -w /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/daemon.h anoncvs-STABLE_1_3/daemon.h +--- /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/daemon.h Wed Dec 31 16:00:00 1969 ++++ daemon.h Sun Feb 3 20:28:38 2002 +@@ -0,0 +1,20 @@ ++struct bidmessage { ++ /* layout will change a lot */ ++ int type; ++ ++}; ++ ++/* Message types */ ++#define MSG_PING 0 /* Are you there */ ++#define MSG_BID 1 /* Place a bid */ ++#define MSG_UPDATE 2 /* Update an auction */ ++#define MSG_UPDATE_ALL 3 /* Update all auctions */ ++#define MSG_ADD 4 /* Add an auction */ ++#define MSG_PREFS 5 /* Update preferences */ ++#define MSG_SYNC 6 /* Time Sync */ ++#define MSG_SHUTDOWN 7 /* Shut down server */ ++#define MSG_ATTACH 8 /* Attach to server */ ++#define MSG_DETACH 9 /* Detach from server */ ++#define MSG_REMOVE 10 /* Remove an auction */ ++#define MSG_SNIPE 11 /* Setup a snipe */ ++ +diff -u -ruN -b -B -w /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/helpers.cpp anoncvs-STABLE_1_3/helpers.cpp +--- /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/helpers.cpp Fri Apr 23 13:23:28 2004 ++++ helpers.cpp Tue Aug 3 08:34:28 2004 +@@ -98,7 +98,7 @@ + } + }; + +-float calculateBidIncrement(float currentBid, char *currency) ++float calculateBidIncrement(float currentBid, const char *currency) + { + // step 1 - parse currentBid into useable int's + /* +@@ -162,13 +162,21 @@ + if (fcb<=600) inc=30; + if (fcb<=120) inc=5; + break; +- case 'D': // deutsche marks (german) ++ case 'D': // deutsche marks (german, obsolete) + inc=100; + if (fcb<10000) inc=10; + if (fcb<1000) inc=5; + if (fcb<100) inc=1; + break; ++ case 'E': // Euro ++ inc = 50; ++ if(fcb < 5000) inc = 10; ++ if(fcb < 1000) inc = 5; ++ if(fcb < 500) inc = 1; ++ if(fcb < 50) inc = 0.5; ++ break; + default: ++ fprintf(stderr, "unknown currency %s\n", currency); + inc=0; + } + fcb = fcb + inc; +@@ -319,9 +327,24 @@ + // strip the html tags + for (u = 0; u < buffLength; u++) { + c = stringToStrip[u]; +- if (c == '<') IncludeFlag=5; +- else if (c == '>') IncludeFlag=10; +- else if (IncludeFlag==10) { ++ if (c == '<') { ++ IncludeFlag=5; ++ if(u+3') { ++ Buff[BuffIdx++] = '\n'; ++ u+=2; ++ } else if (stringToStrip[u+1] == 'b' && \ ++ stringToStrip[u+2] == 'r' && \ ++ stringToStrip[u+3] == '>') { ++ Buff[BuffIdx++] = '\n'; ++ u+=2; ++ } ++ } ++ } else if (c == '>') { ++ IncludeFlag=10; ++ } else if (IncludeFlag==10) { + if ((BuffIdx > 0) && (c == ' ') && + (Buff[BuffIdx-1] != ' ') && + (Buff[BuffIdx-1] != '\n')) +@@ -711,7 +734,9 @@ + NewAuction->stat = '0'; + NewAuction->reserveMet = '0'; + NewAuction->isSnipe = FALSE; ++ NewAuction->isPreBid = FALSE; + NewAuction->EndsValue = 0; ++ NewAuction->UpdTime = 0; + if (NewAuction->infourl) delete NewAuction->infourl; + if (NewAuction->infourl) delete NewAuction->bidurl; + NewAuction->infourl=NULL; +@@ -866,6 +891,9 @@ + + // Parse out currency and price + void parseprice(char *buf,struct auctioninfo * auc, bool isfirst) { ++ char *p = strchr(buf, ':'); ++ if(p) buf = p + 1; ++ + int len; + if ((buf[0]=='$') || (buf[0]=='U' && buf[1]=='S')) strcpy(auc->currency,"$"); + else { +@@ -880,10 +908,8 @@ + buf[len]='\0'; + strip_commas(buf); + +- //if (isfirst) auc->FirstBid = atof(buf); +- //else auc->CurrentBid = atof(buf); +- + auc->CurrentBid = atof(buf); ++ if (isfirst) auc->FirstBid = auc->CurrentBid; + + DPRINTF(DLOW, ("buf='%s'\n", buf)); + DPRINTF(DLOW, ("Price is '%.2f'/'%.2f'\n", auc->CurrentBid, auc->FirstBid)); +@@ -1044,7 +1071,6 @@ + isBuyItNow = 1; + reserveMet = 'b'; + if (!CurrentBid && !FirstBid) { +- streamBuff.getline(LineData, 1024, '\n'); + parseprice(LineData, this, TRUE); + } + break; +@@ -1059,8 +1085,6 @@ + case 5: // bid count + case 22: + if (!BidCount) { +- char bc[80]; +- streamBuff.getline(LineData, 1024, '\n'); + DPRINTF(DLOW, ("LDBC: %s\n", LineData)); + // if instead of the number of bids an item has "Purchases" and + // there was no time left in the auction the auction is not endless +@@ -1070,11 +1094,18 @@ + } else if (strstr(LineData, "Winning bidders list")) { + strcpy(HighBidder, "Dutch Auction"); + } else { +- for(cnt=0; (((LineData[cnt]!=' ') && +- (LineData[cnt]!=0)) && (cnt<14)); ++cnt) +- bc[cnt] = LineData[cnt]; +- bc[cnt] = 0; +- BidCount = atoi(bc); ++ scratch = strchr(LineData, ':'); ++ if(scratch) { ++ int limit = strlen(scratch); ++ for ( int i=0; i < limit; i++ ) ++ { ++ // strip the ':' off the currentBid; ++ scratch[i] = scratch[i + 1]; ++ } ++ BidCount = atoi(scratch); ++ } else { ++ fprintf(stderr, "cannot determine BidCount: propably parser broken\n"); ++ } + DPRINTF(DLOW, ("BidCount: %i\n", BidCount)); + } + } +@@ -1125,6 +1156,7 @@ + unsigned int count; + + streamBuff.getline(LineData, 1024, '\n'); ++ if (*LineData == '\0') streamBuff.getline(LineData, 1024, '\n'); + strncpy(Seller, LineData, 75); + + for (count=0; count < sizeof(Seller); count++) +@@ -1155,8 +1187,19 @@ + case 24: + case 26: // "Buyer:" + if (!HighBidder[0]) { ++ char *p; ++ p = strchr(LineData, ':'); ++ if (p) { ++ if (*(p+1) == '\0') { ++ streamBuff.getline(LineData, 1024, '\n'); ++ p = LineData; ++ } else ++ p++; ++ } else { + streamBuff.getline(LineData, 1024, '\n'); +- strncpy(HighBidder, LineData, 76); ++ p = LineData; ++ } ++ strncpy(HighBidder, p, 76); + for (unsigned int count=0; count < sizeof(HighBidder); count++) + { + if (HighBidder[count] == '(') +@@ -1301,9 +1344,12 @@ + + // now calculate the ending time in seconds and save it if the auction ended + // early due to cancel or "buy it now" +- if (ended_early == 1) ++ if (ended_early == 1) { + EndsValue = 0; +- ++ } else { ++ EndsValue = CalcEndsValue(Ends); ++ if(EndsValue < 0) EndsValue = 0; ++ } + + // now We'll parse the High Bidder and Seller's ratings off their names + // and assign them to .SellerRate and .BidderRate +@@ -1677,8 +1723,21 @@ + 'w','x','y','z','0','1','2','3', + '4','5','6','7','8','9','+','/' + }; ++ + int i; + unsigned char *p = (unsigned char *)store; ++ char *src = NULL; ++ ++ // s is used in triples: ensure engouh space for this ++ if(length % 3) { ++ int slen = length + 2; ++ src = (char*)malloc(slen); ++ if(src) { ++ memset(src, 0, slen); ++ memcpy(src, s, length); ++ s = src; ++ } ++ } + + // Transform the 3x8 bits to 4x6 bits, as required by base64. + for (i = 0; i < length; i += 3) +@@ -1696,6 +1755,8 @@ + *(p - 1) = *(p - 2) = '='; + // ...and zero-terminate it. + *p = '\0'; ++ ++ if(src) free(src); + } + + // Create the authentication header contents for the `Basic' scheme. +diff -u -ruN -b -B -w /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/netstuff.cpp anoncvs-STABLE_1_3/netstuff.cpp +--- /usr/ports/misc/bidwatcher/work/bidwatcher-1.3.15/netstuff.cpp Mon Apr 19 20:33:30 2004 ++++ netstuff.cpp Tue Aug 3 08:34:28 2004 +@@ -156,10 +156,8 @@ + free(hostinfo); + } + +- if(proxyuser != NULL) +- delete proxyuser; +- if(proxypass != NULL) +- delete proxypass; ++ if(proxyuser != NULL) free(proxyuser); ++ if(proxypass != NULL) free(proxypass); + } + + void URL::create(char *newurl,URL *proxy) { -- cgit v1.1