std::string verifyne::Api::b64decode(const std::string str)
{
base64::decoder d;
std::stringstream b64(str);
std::stringstream plain;
d.decode(b64, plain);
std::string ret(plain.str());
return ret;
}
filepos_t EbmlDate::RenderData(IOCallback & output, bool /* bForceRender */, bool /* bWithDefault */)
{
if (GetSize() != 0) {
assert(GetSize() == 8);
big_int64 b64(myDate);
output.writeFully(&b64.endian(),GetSize());
}
return GetSize();
}
Item ItemFactoryImpl::createBase64Binary(const char* aData, size_t aLength,
bool aIsBase64)
{
try {
store::Item_t result;
xs_base64Binary b64( aData, aLength, aIsBase64 );
theItemFactory->createBase64Binary( result, b64 );
return &*result;
}
catch ( std::exception const &e ) {
throw ZORBA_EXCEPTION(
zerr::ZSTR0040_TYPE_ERROR, ERROR_PARAMS( e.what() )
);
}
}
void visit_value(const types::b_binary& value) {
std::size_t b64_len;
b64_len = (value.size / 3 + 1) * 4 + 1;
std::unique_ptr<char> b64(reinterpret_cast<char*>(operator new(b64_len)));
b64_ntop(value.bytes, value.size, b64.get(), b64_len);
out << "{" << std::endl;
pad(1);
out << "\"$type\" : " << value.sub_type << "," << std::endl;
pad(1);
out << "\"$binary\" : " << b64.get() << "," << std::endl;
pad();
out << "}";
}
void addXMLEncapsulatedX509Certificate(xercesc::DOMDocument *doc,
xercesc::DOMNode *root,
bdoc::X509Cert& x509,
const char *id)
{
xercesc::DOMElement *x509val =
doc->createElement(
xercesc::XMLString::transcode(
"EncapsulatedX509Certificate"));
std::vector<unsigned char> der = x509.encodeDER();
xml_schema::Base64Binary b64(&der[0], der.size());
x509val->setTextContent(
xercesc::XMLString::transcode(b64.encode().c_str()));
x509val->setAttribute(
xercesc::XMLString::transcode("Id"),
xercesc::XMLString::transcode(id));
root->appendChild(x509val);
}
void xml_writer_impl::write_element(const variant& element)
{
try
{
if (element.is<variant::Collection>() && element.empty() && element.type() != variant::DataTable)
{
write_empty_element();
return;
}
switch(element.type())
{
case variant::None:
{
write_empty_element();
break;
}
case variant::Any:
case variant::String:
{
if (element.as<std::string>().empty())
{
write_empty_element();
break;
}
}
case variant::Float:
case variant::Double:
case variant::Int32:
case variant::UInt32:
case variant::Int64:
case variant::UInt64:
case variant::Boolean:
case variant::Date:
case variant::Time:
case variant::DateTime:
{
m_os << start_tag();
write_text(element);
m_os << end_tag();
break;
}
case variant::Dictionary:
case variant::Bag:
{
if ((m_mode & xml_mode::Preserve)!=0)
{
if (element.has_key(xml_attributes))
{
m_stack.top().m_attributes = element[xml_attributes];
if (element.size()==1)
{
write_empty_element();
break;
}
}
m_os << start_tag();
bool prev_is_text = false;
variant::const_iterator it, end(element.end());
for (it=element.begin(); it!=end; ++it)
{
if (it.key()==xml_attributes)
{
continue;
}
else if (it.key()==xml_text)
{
write_text(it.value());
prev_is_text = true;
}
else if (it.key()==xml_instruction)
{
push(it.key());
if (!prev_is_text)
{
m_os << indent();
}
write_instruction(it.value());
prev_is_text = false;
pop();
}
else if (it.key()==xml_comment)
{
push(it.key());
if (!prev_is_text)
{
m_os << indent();
}
write_comment(it.value());
prev_is_text = false;
pop();
}
else
{
push(it.key());
if (!prev_is_text)
{
m_os << indent();
}
write_element(it.value());
prev_is_text = false;
pop();
}
}
if (!prev_is_text)
{
m_os << indent();
}
m_os << end_tag();
}
else
{
m_os << start_tag();
variant::const_iterator it, end(element.end());
for (it=element.begin(); it!=end; ++it)
{
push(it.key());
m_os << indent();
write_variant(it.value());
pop();
}
m_os << indent() << end_tag();
}
break;
}
case variant::List:
{
m_os << start_tag();
BOOST_FOREACH(const variant& item, element)
{
push();
m_os << indent();
write_variant(item);
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
case variant::Tuple:
{
m_stack.top().m_attributes.insert("size", variant(element.size()));
m_os << start_tag();
BOOST_FOREACH(const variant& item, element)
{
push();
m_os << indent();
write_variant(item);
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
case variant::TimeSeries:
{
m_os << start_tag();
variant::const_iterator it, end = element.end();
for (it=element.begin(); it!=end; ++it)
{
push().insert("time", variant(it.time()));
m_os << indent();
write_variant(it.value());
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
case variant::DataTable:
{
const data_table& dt = element.m_value.get<variant::DataTable>();
m_stack.top().m_attributes
.insert("rows", variant(dt.size()))
.insert("columns", variant(dt.columns().size()));
m_os << start_tag();
if (!dt.columns().empty())
{
push("Columns");
m_os << indent() << start_tag();
for (data_table::column_container_type::const_iterator column_iter = dt.columns().begin()
; column_iter != dt.columns().end()
; ++column_iter)
{
push("Column")
.insert("name", variant(column_iter->name()))
.insert("type", variant(variant::enum_to_string(column_iter->type())));
m_os << indent();
write_empty_element();
pop();
}
m_os << indent() << end_tag();
pop();
}
for (data_table::column_container_type::const_iterator column_iter = dt.columns().begin()
; column_iter != dt.columns().end()
; ++column_iter)
{
push("Column").insert("name", variant(column_iter->name()));
m_os << indent() << start_tag();
if (column_iter->type() & variant_base::Primitive)
{
boost::scoped_ptr<data_table_column_writer> column_writer(
make_data_table_column_stream_writer(*column_iter, m_os)
);
while (column_writer->has_next())
{
push("V");
m_os << indent() << start_tag();
column_writer->write();
m_os << end_tag();
pop();
column_writer->advance();
}
}
else
{
variant::const_iterator iter(column_iter->begin());
variant::const_iterator end(column_iter->end());
while (iter != end)
{
push("V");
m_os << indent();
write_variant(*(iter++));
pop();
}
}
m_os << indent() << end_tag();
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
case variant::Buffer:
{
m_os << start_tag();
const void *data = element.as<void*>();
size_t size = element.size();
if (data!=nullptr && size>0)
{
unsigned int n = 0;
boost::scoped_ptr<char> b64(detail::b64_encode((const char*)data, (unsigned int)size, &n));
if (!b64.get())
{
boost::throw_exception(variant_error("Unable to base64 encode data"));
}
m_os << b64.get();
}
m_os << end_tag();
break;
}
case variant::Object:
{
const object& obj(element.as<object>());
// write class name
m_stack.top().m_attributes
.insert("class", variant(obj.name()))
.insert("version", variant(obj.version()));
m_os << start_tag();
// write parameter dictionary
variant params;
obj.deflate(params);
push("params");
m_os << indent();
write_variant(params);
pop();
m_os << indent();
m_os << end_tag();
break;
}
case variant::Exception:
{
m_os << start_tag();
exception_data e(element.as<exception_data>());
push("type");
m_os << indent();
write_element(variant(e.type()));
pop();
push("message");
m_os << indent();
write_element(variant(e.message()));
pop();
if (!e.source().empty())
{
push("source");
m_os << indent();
write_element(variant(e.source()));
pop();
}
if (!e.stack().empty())
{
push("stack");
m_os << indent();
write_element(variant(e.stack()));
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
case variant::Array:
{
const typed_array& a(element.as<typed_array>());
m_stack.top().m_attributes
.insert("size", variant(a.size()))
.insert("type", variant(variant::enum_to_string(a.type())));
m_os << start_tag();
for (size_t i=0; i<a.size(); ++i)
{
push();
m_os << indent();
write_element(variant(a[i]));
pop();
}
m_os << indent();
m_os << end_tag();
break;
}
default:
boost::throw_exception(variant_error("Case exhaustion: " + variant::enum_to_string(element.type())));
}
void CommonTestsSuite::test_b64() {
TS_ASSERT(b64("this is a test1") == "dGhpcyBpcyBhIHRlc3Qx");
TS_ASSERT(b64("this is a test") == "dGhpcyBpcyBhIHRlc3Q=");
TS_ASSERT(b64("this is a tes") == "dGhpcyBpcyBhIHRlcw==");
TS_ASSERT(b64("") == "");
}
int main(int argc, char * argv [])
{
ulxr::intializeLog4J(argv[0]);
int success = 0;
#ifdef STRESS_IT
for (int i= 0; i < 1000; ++i)
{
#endif
try
{
ULXR_COUT << ULXR_PCHAR("Testing patterns\n");
ULXR_COUT << ULXR_PCHAR("boolPattern\n") << std::flush;
testPattern(boolPattern, sizeof(boolPattern));
ULXR_COUT << ULXR_PCHAR("int1Pattern\n");
testPattern(int1Pattern, sizeof(int1Pattern));
ULXR_COUT << ULXR_PCHAR("int2Pattern\n");
testPattern(int2Pattern, sizeof(int2Pattern));
ULXR_COUT << ULXR_PCHAR("doublePattern\n");
testPattern(doublePattern, sizeof(doublePattern));
ULXR_COUT << ULXR_PCHAR("stringPattern\n");
testPattern(stringPattern, sizeof(stringPattern));
ULXR_COUT << ULXR_PCHAR("base64Pattern\n");
testPattern(base64Pattern, sizeof(base64Pattern));
ULXR_COUT << ULXR_PCHAR("datePattern\n");
testPattern(datePattern, sizeof(datePattern));
ULXR_COUT << ULXR_PCHAR("struct1Pattern\n");
testPattern(struct1Pattern, sizeof(struct1Pattern));
ULXR_COUT << ULXR_PCHAR("struct2Pattern\n");
testPattern(struct2Pattern, sizeof(struct2Pattern));
ULXR_COUT << ULXR_PCHAR("arrayPattern\n");
testPattern(arrayPattern, sizeof(arrayPattern));
ULXR_COUT << ULXR_PCHAR("callPattern\n");
testCallPattern(callPattern, sizeof(callPattern));
ULXR_COUT << ULXR_PCHAR("emptyCallPattern\n");
testCallPattern(emptyCallPattern, sizeof(emptyCallPattern));
ULXR_COUT << ULXR_PCHAR("respPattern\n");
testRespPattern(respPattern, sizeof(respPattern));
ULXR_COUT << ULXR_PCHAR("implPattern\n");
testPattern(implPattern, sizeof(implPattern));
ULXR_COUT << ULXR_PCHAR("emptyArrayPattern\n");
testRespPattern(emptyArrayPattern, sizeof(emptyArrayPattern));
ULXR_COUT << ULXR_PCHAR("emptyRespPattern\n");
testRespPattern(emptyRespPattern, sizeof(emptyRespPattern));
ULXR_COUT << ULXR_PCHAR("emptyStructPattern\n");
testRespPattern(emptyStructPattern, sizeof(emptyStructPattern));
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ULXR_PCHAR("MethodResponse abc\n");
ulxr::MethodResponse mr1(123, ULXR_PCHAR("faultstr_m"));
ULXR_COUT << ulxr::binaryDebugOutput(mr1.getWbXml());
ULXR_COUT << std::endl << mr1.getXml(0) << std::endl;
ulxr::MethodResponse mr2(ulxr::Integer(1));
ULXR_COUT << ulxr::binaryDebugOutput(mr2.getWbXml());
ULXR_COUT << std::endl << mr2.getXml(0) << std::endl;
ulxr::MethodResponse mr3;
ULXR_COUT << ulxr::binaryDebugOutput(mr3.getWbXml());
ULXR_COUT << std::endl << mr3.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ulxr::MethodCall mc (ULXR_PCHAR("test.call"));
ULXR_COUT << ulxr::binaryDebugOutput(mc.getWbXml());
ULXR_COUT << std::endl << mc.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("====================================================\n");
ulxr::Boolean b(true);
ulxr::Integer i(123);
ulxr::Double d(123.456);
ulxr::RpcString s("<>&\"\'string<>&\"\'");
ulxr::DateTime dt(ULXR_PCHAR("20020310T10:23:45"));
ulxr::Base64 b64(ULXR_PCHAR("ABASrt466a90"));
ulxr::Struct st;
ulxr::Array ar;
ULXR_COUT << ulxr::binaryDebugOutput(b.getWbXml()) << std::endl;
ULXR_COUT << b.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(i.getWbXml()) << std::endl;
ULXR_COUT << i.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(d.getWbXml()) << std::endl;
ULXR_COUT << d.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(s.getWbXml()) << std::endl;
ULXR_COUT << s.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(dt.getWbXml()) << std::endl;
ULXR_COUT << dt.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(b64.getWbXml()) << std::endl;
ULXR_COUT << b64.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(st.getWbXml()) << std::endl;
ULXR_COUT << st.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("----------------------------------------------------\n");
ULXR_COUT << ulxr::binaryDebugOutput(ar.getWbXml()) << std::endl;
ULXR_COUT << ar.getXml(0) << std::endl;
ULXR_COUT << ULXR_PCHAR("====================================================\n");
ULXR_COUT << "wbToken_Value " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Value) << std::endl;
ULXR_COUT << "wbToken_Array " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Array) << std::endl;
ULXR_COUT << "wbToken_Data " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Data) << std::endl;
ULXR_COUT << "wbToken_Struct " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Struct) << std::endl;
ULXR_COUT << "wbToken_Member " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Member) << std::endl;
ULXR_COUT << "wbToken_Name " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Name) << std::endl;
ULXR_COUT << "wbToken_Boolean " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Boolean) << std::endl;
ULXR_COUT << "wbToken_Int " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Int) << std::endl;
ULXR_COUT << "wbToken_I4 " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_I4) << std::endl;
ULXR_COUT << "wbToken_Double " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Double) << std::endl;
ULXR_COUT << "wbToken_String " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_String) << std::endl;
ULXR_COUT << "wbToken_Base64 " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Base64) << std::endl;
ULXR_COUT << "wbToken_Date " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_Date) << std::endl;
ULXR_COUT << std::endl;
ULXR_COUT << "wbToken_MethodCall " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodCallParserWb::wbToken_MethodCall) << std::endl;
ULXR_COUT << "wbToken_MethodName " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodCallParserWb::wbToken_MethodName) << std::endl;
ULXR_COUT << "wbToken_Params " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodCallParserWb::wbToken_Params) << std::endl;
ULXR_COUT << "wbToken_Param " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodCallParserWb::wbToken_Param) << std::endl;
ULXR_COUT << std::endl;
ULXR_COUT << "wbToken_MethodResponse " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodResponseParserWb::wbToken_MethodResponse) << std::endl;
ULXR_COUT << "wbToken_Fault " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodResponseParserWb::wbToken_Fault) << std::endl;
ULXR_COUT << "wbToken_Params " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodResponseParserWb::wbToken_Params) << std::endl;
ULXR_COUT << "wbToken_Param " << ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodResponseParserWb::wbToken_Param) << std::endl;
ULXR_COUT << std::endl;
ULXR_COUT << "wbToken_ValueParserLast "
<< ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::ValueParserWb::wbToken_ValueParserLast) << std::endl;
ULXR_COUT << "wbToken_CallParserLast "
<< ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodCallParserWb::wbToken_CallParserLast) << std::endl;
ULXR_COUT << "wbToken_ResponseParserLast "
<< ulxr::HtmlFormHandler::makeHexNumber((unsigned char)ulxr::MethodResponseParserWb::wbToken_ResponseParserLast) << std::endl;
}
catch(ulxr::Exception &ex)
{
ULXR_COUT << ULXR_PCHAR("Error occured: ")
<< ULXR_GET_STRING(ex.why()) << std::endl;
success= 1;
}
#ifdef STRESS_IT
}
#endif
return success;
}
string b64(string source) {
return b64((uint8_t *) STR(source), source.size());
}
int search_freedb (splt_state *state)
{
int fd, i, tot=0;
char buffer[BUFFERSIZE], message[1024], junk[1024];
char *c, *e=NULL;
FILE *output = NULL;
struct sockaddr_in host;
struct hostent *h;
struct addr dest;
cd_state *cdstate;
if ((c=getenv("HOME"))!=NULL) sprintf(message, "%s/"PROXYCONFIG, c);
else strncpy(message, PROXYCONFIG, strlen(PROXYCONFIG));
if (!(output=fopen(message, "r"))) {
if (!(output=fopen(message, "w+"))) {
fprintf(stderr, "\nWARNING Can't open config file ");
perror(message);
}
else {
fprintf (stderr, "Will you use a proxy? (y/n): ");
fgets(junk, 200, stdin);
if (junk[0]=='y') {
fprintf (stderr, "Proxy Address: ");
fgets(junk, 200, stdin);
fprintf (output, "PROXYADDR=%s", junk);
fprintf (stderr, "Proxy Port: ");
fgets(junk, 200, stdin);
fprintf (output, "PROXYPORT=%s", junk);
fprintf (stderr, "Need authentication? (y/n): ");
fgets(junk, 200, stdin);
if (junk[0]=='y') {
fprintf (output, "PROXYAUTH=1\n");
fprintf (stderr, "Would you like to save password (insecure)? (y/n): ");
fgets(junk, 200, stdin);
if (junk[0]=='y') {
login (message);
e = b64(message, strlen(message));
fprintf (output, "%s\n", e);
memset(message, 0x00, strlen(message));
memset(e, 0x00, strlen(e));
free(e);
}
}
}
}
}
dest = useproxy(output, dest);
if (output != NULL)
fclose(output);
do {
fprintf (stdout, "\n\t____________________________________________________________]");
fprintf (stdout, "\r Search: [");
fgets(junk, 800, stdin);
junk[strlen(junk)-1]='\0';
} while ((strlen(junk)==0)||(checkstring(junk)!=0));
i=0;
while ((junk[i]!='\0')&&(i<800))
if (junk[i]==' ') junk[i++]='+';
else i++;
fprintf (stderr, "\nConnecting to %s...\n", dest.hostname);
if((h=gethostbyname(dest.hostname))==NULL) {
herror(dest.hostname);
exit(1);
}
memset(&host, 0x0, sizeof(host));
host.sin_family=AF_INET;
host.sin_addr.s_addr=((struct in_addr *) (h->h_addr)) ->s_addr;
host.sin_port=htons(dest.port);
if((fd=socket(AF_INET, SOCK_STREAM, 0))==-1) {
perror("socket");
exit(1);
}
if ((connect(fd, (void *)&host, sizeof(host)))==-1) {
perror("connect");
exit(1);
}
if (dest.proxy) {
sprintf(message,"GET http://www.freedb.org"SEARCH" "PROXYDLG, junk);
if (dest.auth!=NULL)
sprintf (message, "%s"AUTH"%s\n", message, dest.auth);
strncat(message, "\n", 1);
}
else sprintf(message,"GET "SEARCH"\n", junk);
if((send(fd, message, strlen(message), 0))==-1) {
perror("send");
exit(1);
}
fprintf (stderr, "Host contacted. Waiting for answer...\n");
memset(buffer, 0x00, BUFFERSIZE);
if ((cdstate = (cd_state *) malloc (sizeof(cd_state)))==NULL) {
perror("malloc");
exit(1);
}
cdstate->foundcd = 0;
do {
tot=0;
c = buffer;
do {
i = recv(fd, c, BUFFERSIZE-(c-buffer)-1, 0);
if (i==-1) break;
tot += i;
buffer[tot]='\0';
c += i;
} while ((i>0)&&(tot<BUFFERSIZE-1)&&((e=strstr(buffer, "</html>"))==NULL));
tot = find_cd(buffer, tot, cdstate);
if (tot==-1) continue;
if (tot==-2) break;
} while ((i>0)&&(e==NULL)&&(cdstate->foundcd<MAXCD));
closesocket(fd);
if (cdstate->foundcd<=0) {
if (dest.proxy) {
if (strstr(buffer, "HTTP/1.0")!=NULL) {
if ((c = strchr (buffer, '\n'))!=NULL)
buffer[c-buffer]='\0';
fprintf (stderr, "Proxy Reply: %s\n", buffer);
}
}
if (cdstate->foundcd==0) return -1;
if (cdstate->foundcd==-1) return -2;
}
if (cdstate->foundcd==MAXCD) fprintf (stderr, "\nMax cd number reached, this search may be too generic.\n");
fprintf (stdout, "\n");
do {
i=0;
fprintf (stdout, "Select cd #: ");
fgets(message, 254, stdin);
message[strlen(message)-1]='\0';
tot=0;
if (message[tot]=='\0') i=-1;
while(message[tot]!='\0')
if (isdigit(message[tot++])==0) {
fprintf (stdout, "Please ");
i=-1;
break;
}
if (i!=-1) i = atoi (message);
} while ((i>=cdstate->foundcd) || (i<0));
state->id.genre = getgenre(cdstate->discs[i].category);
if (dest.proxy) {
sprintf(message, "GET "FREEDBHTTP"cmd=cddb+read+%s+%s&hello=nouser+mp3splt.net+"NAME"+"VER"&proto=5 "PROXYDLG,
cdstate->discs[i].category, cdstate->discs[i].discid);
if (dest.auth!=NULL) {
sprintf (message, "%s"AUTH"%s\n", message, dest.auth);
memset(dest.auth, 0x00, strlen(dest.auth));
free(dest.auth);
}
strncat(message, "\n", 1);
}
else {
sprintf(message, "CDDB READ %s %s\n", cdstate->discs[i].category, cdstate->discs[i].discid);
host.sin_port=htons(PORT2);
}
fprintf (stderr, "\nContacting "FREEDB" to query selected cd...\n");
if((fd=socket(AF_INET, SOCK_STREAM, 0))==-1) {
perror("socket");
exit(1);
}
if ((connect(fd, (void *)&host, sizeof(host)))==-1) {
perror("connect");
exit(1);
}
if (!dest.proxy) {
i=recv(fd, buffer, BUFFERSIZE-1, 0);
buffer[i]='\0';
if (strncmp(buffer,"201",3)!=0) return -4;
if((send(fd, HELLO, strlen(HELLO), 0))==-1) {
perror("send");
exit(1);
}
i=recv(fd, buffer, BUFFERSIZE-1, 0);
buffer[i]='\0';
if (strncmp(buffer,"200",3)!=0) return -4;
}
if((send(fd, message, strlen(message), 0))==-1) {
perror("send");
exit(1);
}
fprintf (stderr, "Host contacted. Waiting for answer...\n");
memset(buffer, 0x00, BUFFERSIZE);
c = buffer;
tot=0;
do {
i = recv(fd, c, BUFFERSIZE-(c-buffer)-1, 0);
if (i==-1) break;
tot += i;
buffer[tot]='\0';
c += i;
} while ((i>0)&&(tot<BUFFERSIZE-1)&&((e=strstr(buffer, "\n."))==NULL));
if (!dest.proxy)
if((send(fd, "quit\n", 5, 0))==-1) {
perror("send");
exit(1);
}
closesocket(fd);
if (tot==0) return -4;
if (e!=NULL)
buffer[e-buffer+1]='\0';
if ((strstr(buffer, "database entry follows"))==NULL) {
if ((c = strchr (buffer, '\n'))!=NULL)
buffer[c-buffer]='\0';
fprintf (stderr, "Invalid server answer: %s\n", buffer);
return -5;
}
else {
if ((c = strchr (buffer, '#'))==NULL)
return -5;
if (!(output=fopen(CDDBFILE, "w"))) {
perror(CDDBFILE);
exit(1);
}
fprintf (output, c);
fclose(output);
}
fprintf (stderr, "OK, "CDDBFILE" has been written.\n");
free(cdstate);
return 0;
}
struct addr useproxy(FILE *in, struct addr dest)
{
char line[270];
char *ptr;
dest.proxy=0;
memset(dest.hostname, 0, 256);
memset(line, 0, 270);
if (in != NULL) {
fseek(in, 0, SEEK_SET);
if (fgets(line, 266, in)!=NULL) {
if (strstr(line, "PROXYADDR")!=NULL) {
line[strlen(line)-1]='\0';
if ((ptr = strchr(line, '='))!=NULL) {
ptr++;
strncpy(dest.hostname, ptr, 255);
}
if (fgets(line, 266, in)!=NULL) {
if (strstr(line, "PROXYPORT")!=NULL) {
line[strlen(line)-1]='\0';
if ((ptr = strchr(line, '='))!=NULL) {
ptr++;
dest.port = atoi (ptr);
dest.proxy=1;
}
fprintf (stderr, "Using Proxy: %s on Port %d\n", dest.hostname, dest.port);
if (fgets(line, 266, in)!=NULL) {
if (strstr(line, "PROXYAUTH")!=NULL) {
line[strlen(line)-1]='\0';
if ((ptr = strchr(line, '='))!=NULL) {
ptr++;
if (ptr[0]=='1') {
if (fgets(line, 266, in)!=NULL) {
dest.auth = malloc(strlen(line)+1);
if (dest.auth==NULL) {
perror("malloc");
exit(1);
}
memset(dest.auth, 0x0, strlen(line)+1);
strncpy(dest.auth, line, strlen(line));
}
else {
login(line);
dest.auth = b64(line, strlen(line));
memset(line, 0x00, strlen(line));
}
}
}
}
}
else dest.auth = NULL;
}
}
}
}
}
if (!dest.proxy) {
strncpy(dest.hostname, FREEDB, 255);
dest.port = PORT1;
}
return dest;
}
