1

/* $Id$ */

     2

     3

/** @file newgrf_download.cpp GUI to download NewGRFs. */

     4

#include "../stdafx.h"

     5

#include "../openttd.h"

     6

#include "../strings_func.h"

     7

#include "../date_func.h"

     8

#include "../gui.h"

     9

#include "../window_gui.h"

    10

#include "../textbuf_gui.h"

    11

#include "../variables.h"

    12

#include "../newgrf.h"

    13

#include "newgrf_download.h"

    14

#include "core/config.h"

    15

#include "../functions.h"

    16

#include "../debug.h"

    17

#include "../window_func.h"

    18

#include "../core/alloc_func.hpp"

    19

#include "../string_func.h"

    20

#include "../gfx_func.h"

    21

#include "../querystring_gui.h"

    22

#include "../sortlist_type.h"

    24

#include "../rev.h"

    25

    26

// XXX: ...

    27

#include <curl/curl.h>

    28

    29

#include "table/strings.h"

    30

#include "../table/sprites.h"

    31

    32

static int _has_curl_init = 0;

    33

    34

static CURLcode do_init_curl () {

    35

    CURLcode err;

    36

    37

    if (!_has_curl_init) {

    38

        // XXX: be smarter about what to initialize

    39

        if ((err = curl_global_init(CURL_GLOBAL_ALL)))

    40

            return err;

    41

    42

        _has_curl_init = 1;

    43

    }

    44

    45

    return CURLE_OK;

    46

}

    47

    48

struct check_write_ctx {

    49

    char *buf;

    50

    size_t len;

    51

    size_t offset;

    52

};

    53

    54

#define QUERY_ITEM_SIZE (                   \

    55

            4   /* the "grf=" prefix */     \

    56

          + 8   /* the GRFID, in hex */     \

    57

          + 1   /* the ":" */               \

    58

          + 32  /* the md5sum, in hex */    \

    59

          + 1   /* the "&" or '\0' */       \

    60

        )

    61

    62

static size_t check_available_write_cb (void *ptr, size_t size, size_t nmemb, void *arg) {

    63

    struct check_write_ctx *ctx = (struct check_write_ctx *) arg;

    64

    65

    // total number of bytes

    66

    size_t len = size * nmemb;

    67

    68

    // realloc if needed

    69

    if (ctx->offset + len + 1 > ctx->len) {

    70

        ctx->len *= 2;

    71

        ctx->buf = ReallocT<char>(ctx->buf, ctx->len);

    72

    }

    73

    74

    // thankfully we only have a limited amount of data..

    75

    memcpy(ctx->buf + ctx->offset, ptr, len);

    76

    ctx->offset += len;

    77

    *(ctx->buf + ctx->offset) = '\0';

    78

    79

    return len;

    80

}

    81

    82

/** Ask the master database about the availablity of the given NewGRFs, and update

    83

 * the GRFConfigs that are avilable to GCS_AVAILABLE

    84

 * @param config pointer to a linked-list of grfconfig's needed */

    86

{

    87

    GRFConfig *c;

    88

    int i;

    89

    char md5buf[64];

    90

    struct check_write_ctx write_ctx;

    91

    CURL *curl;

    92

    char api_url[512], useragent[512];

    93

    char curl_errbuf[CURL_ERROR_SIZE];

    94

    long http_code;

    95

    char *buf_ptr;

    96

    CURLcode err;

    99

   100

    // initialize to a safe state for error handling

   101

    curl = write_ctx.buf = NULL;

   102

   103

    // count how many NewGRFs in our list

   104

    for (c = list, i = 0; c != NULL; c = c->next, i++) {}

   105

   106

    // how many bytes these take up...

   107

    int query_size = i * QUERY_ITEM_SIZE;

   108

   109

    // allocate the buffer for the query data

   110

    char *query_buf = MallocT<char>(query_size), *query_ptr = query_buf;

   111

   112

    // build the query

   113

    for (c = list; c != NULL; c = c->next) {

   114

   115

        // the "&", except not for the first entry

   116

        if (c != list)

   117

            *(query_ptr++) = '&';

   118

   119

        // format the md5sum

   120

        md5sumToString(md5buf, lastof(md5buf), c->md5sum);

   121

   122

        // snprintf the entry into the query buffer

   123

        assert(snprintf(query_ptr, QUERY_ITEM_SIZE, "grf=%08X:%32s", BSWAP32(c->grfid), md5buf) == QUERY_ITEM_SIZE -1);

   124

   125

        // advance the query_ptr to point at the nul byte

   126

        query_ptr += QUERY_ITEM_SIZE - 1;

   127

    }

   128

   129

    // buil the target URL by formatting NETWORK_NEWGRF_MASTER_API with the method as the only parameter

   130

    assert(snprintf(api_url, sizeof(api_url), NETWORK_NEWGRF_MASTER_API, "search") < 512);

   131

   132

    // our useragent

   133

    assert(snprintf(useragent, sizeof(useragent), NETWORK_HTTP_USER_AGENT, _openttd_revision) < 512);

   134

   135

    // receiving is so damn hard...

   136

    write_ctx.buf = MallocT<char>(512);

   137

    write_ctx.len = 512;

   138

    write_ctx.offset = 0;

   139

   140

    // set up curl globally if needed

   141

    if ((err = do_init_curl())) {

   142

        DEBUG(grfdl, 0, "curl_global_init failed: %s", curl_easy_strerror(err));

   143

        goto error;

   144

    }

   145

   146

    // allocate a new curl_easy

   147

    if ((curl = curl_easy_init()) == NULL) {

   148

        DEBUG(grfdl, 0, "curl_easy_init failed");

   149

        goto error;

   150

    }

   151

   152

    // let's set some options...

   153

    if (

   154

            (CURLE_OK != (err = curl_easy_setopt(curl, CURLOPT_VERBOSE, 1)))        // XXX: tie this in with OpenTTD's debug stuff

   155

    /*            

   156

            curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, XXX)

   157

    */            

   158

        ||  (CURLE_OK != (err = curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1)))             // no progress meter on stdout, thx

   160

        ||  (CURLE_OK != (err = curl_easy_setopt(curl, CURLOPT_URL, api_url)))              // the URL to retrieve

   161

        ||  (CURLE_OK != (err = curl_easy_setopt(curl, CURLOPT_USERAGENT, useragent)))      // the User-agent to use

   162

        ||  (CURLE_OK != (err = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, query_buf)))     // the POST data

   163

        ||  (CURLE_OK != (err = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &check_available_write_cb)))

   164

        ||  (CURLE_OK != (err = curl_easy_setopt(curl, CURLOPT_WRITEDATA, &write_ctx)))     // the write buffer

   165

    ) {

   166

        DEBUG(grfdl, 0, "curl_easy_setopt failed: %s", curl_easy_strerror(err));

   167

        goto error;

   168

    }

   169

   170

    // XXX: currently this freezes the UI..

   171

    if ((err = curl_easy_perform(curl))) {

   172

        DEBUG(grfdl, 0, "the curl request failed: %s", curl_easy_strerror(err));

   173

        goto error;

   174

    }

   175

   176

    // get the HTTP return code

   177

    if ((err = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code))) {

   178

        DEBUG(grfdl, 0, "curl_easy_getinfo failed: %s", curl_easy_strerror(err));

   179

        goto error;

   180

    }

   181

   182

    if (http_code != 200) {

   183

        DEBUG(grfdl, 0, "Bad HTTP response code: %d", http_code);

   184

        goto error;

   185

    }

   186

   187

    // start parsing...

   188

    buf_ptr = write_ctx.buf;

   189

   190

    while (buf_ptr < write_ctx.buf + write_ctx.offset) {

   191

        // replace the \n with a \0

   192

        char *nl = strchr(buf_ptr, '\n');

   193

   194

        if (!nl) {

   195

            DEBUG(grfdl, 0, "Incomplete line in search response: %s", buf_ptr);

   196

            goto error;

   197

        }

   198

   199

        *nl = '\0';

   200

   201

        // check the format

   202

        if (buf_ptr[8] != ':' || buf_ptr[8 + 1 + 32] != ':') {

   203

            DEBUG(grfdl, 0, "Invalid line in search response: %s", buf_ptr);

   204

            goto error;

   205

        }

   206

   207

        // separate out the fields

   208

        buf_ptr[8] = buf_ptr[8 + 1 + 32] = '\0';

   209

   210

        // parse the GRFID...

   211

        char *invalid;

   212

        uint32 grfid = strtol(buf_ptr + 0, &invalid, 16);

   213

   214

        if (*invalid) {

   215

            DEBUG(grfdl, 0, "Invalid GRFID in search response: %s", buf_ptr);

   216

            goto error;

   217

        }

   218

   219

        // parse the md5sum

   220

        uint8 md5sum[16]; 

   221

   222

        if (StringToMd5sum(md5sum, buf_ptr + 8 + 1)) {

   223

            DEBUG(grfdl, 0, "Invalid md5sum in search response: %s", buf_ptr);

   224

            goto error;

   225

        }

   226

   227

        // copy the URL

   228

        char *url = strdup(buf_ptr + 8 + 1 + 32 + 1);

   229

   230

        // look for the GRF

   231

        for (c = list; c != NULL; c = c->next) {

   232

            if (BSWAP32(c->grfid) == grfid && memcmp(c->md5sum, md5sum, 16) == 0) {

   233

                DEBUG(grfdl, 0, "Found %08X:%s at %s", buf_ptr + 0, buf_ptr + 8 + 1, url);

   234

   235

                c->filename = url;

   236

                c->status = GCS_AVAILABLE;

   240

                break;

   241

            } 

   242

        }

   243

   244

        // free the allocated memory if it wasn't stored in a GRFConfig

   245

        if (c == NULL) {

   246

            free(url);

   247

        }

   248

   249

        // move on to the next line

   250

        buf_ptr = nl + 1;

   251

    }

   255

   256

error :

   257

    // cleanup

   258

    free(write_ctx.buf);

   259

   260

    if (curl)

   261

        curl_easy_cleanup(curl);

   373

}

   374

   375

// XXX: copy-pasted from newgrf_gui.cpp

   376

static void ShowDownloadNewGRFInfo(const GRFConfig *c, uint x, uint y, uint w, uint bottom, bool show_params)

   377

{

   378

	char buff[256];

   379

   380

	if (c->error != NULL) {

   381

		char message[512];

   382

		if (c->error->custom_message == NULL) {

   383

			SetDParamStr(0, c->filename);

   384

			SetDParamStr(1, c->error->data);

   385

			for (uint i = 0; i < c->error->num_params; i++) {

   386

				uint32 param = 0;

   387

				byte param_number = c->error->param_number[i];

   388

   389

				if (param_number < c->num_params) param = c->param[param_number];

   390

   391

				SetDParam(2 + i, param);

   392

			}

   393

   394

			GetString(message, c->error->message, lastof(message));

   395

		} else {

   396

			SetDParamStr(0, c->error->custom_message);

   397

			GetString(message, STR_JUST_RAW_STRING, lastof(message));

   398

		}

   399

   400

		SetDParamStr(0, message);

   401

		y += DrawStringMultiLine(x, y, c->error->severity, w, bottom - y);

   402

	}

   403

   404

	/* Draw filename or not if it is not known (GRF sent over internet) */

   405

	if (c->filename != NULL) {

   406

		SetDParamStr(0, c->filename);

   407

		y += DrawStringMultiLine(x, y, STR_NEWGRF_FILENAME, w, bottom - y);

   408

	}

   409

   410

	/* Prepare and draw GRF ID */

   411

	snprintf(buff, lengthof(buff), "%08X", BSWAP32(c->grfid));

   412

	SetDParamStr(0, buff);

   413

	y += DrawStringMultiLine(x, y, STR_NEWGRF_GRF_ID, w, bottom - y);

   414

   415

	/* Prepare and draw MD5 sum */

   416

	md5sumToString(buff, lastof(buff), c->md5sum);

   417

	SetDParamStr(0, buff);

   418

	y += DrawStringMultiLine(x, y, STR_NEWGRF_MD5SUM, w, bottom - y);

   419

   420

	/* Show GRF parameter list */

   421

	if (show_params) {

   422

		if (c->num_params > 0) {

   423

			GRFBuildParamList(buff, c, lastof(buff));

   424

			SetDParam(0, STR_JUST_RAW_STRING);

   425

			SetDParamStr(1, buff);

   426

		} else {

   427

			SetDParam(0, STR_01A9_NONE);

   428

		}

   429

		y += DrawStringMultiLine(x, y, STR_NEWGRF_PARAMETER, w, bottom - y);

   430

	}

   431

   432

	/* Show flags */

   433

	if (c->status == GCS_NOT_FOUND)        y += DrawStringMultiLine(x, y, STR_NEWGRF_NOT_FOUND, w, bottom - y);

   434

	if (c->status == GCS_DISABLED)         y += DrawStringMultiLine(x, y, STR_NEWGRF_DISABLED, w, bottom - y);

   435

	if (HasBit(c->flags, GCF_COMPATIBLE)) y += DrawStringMultiLine(x, y, STR_NEWGRF_COMPATIBLE_LOADED, w, bottom - y);

   436

   437

	/* Draw GRF info if it exists */

   438

	if (c->info != NULL && !StrEmpty(c->info)) {

   439

		SetDParam(0, STR_JUST_RAW_STRING);

   440

		SetDParamStr(1, c->info);

   441

		y += DrawStringMultiLine(x, y, STR_02BD, w, bottom - y);

   442

	} else {

   443

		y += DrawStringMultiLine(x, y, STR_NEWGRF_NO_INFO, w, bottom - y);

   444

	}

   445

}

   446

   447

/**

   448

 * Window for downloading NewGRF files

   449

 */

   450

struct NewGRFDownloadWindow : public Window {

   451

	/* Names of the add a newgrf window widgets */

   452

	enum DownloadNewGRFWindowWidgets {

   453

        DNGRFS_CLOSEBOX = 0,

   454

		DNGRFS_CAPTION,

   455

		DNGRFS_BACKGROUND,

   456

		DNGRFS_FILE_LIST,

   457

		DNGRFS_SCROLLBAR,

   458

		DNGRFS_NEWGRF_INFO,

   459

		DNGRFS_CHECK_AVAILABLE,

   460

		DNGRFS_DOWNLOAD_AVAILABLE,

   461

		DNGRFS_RESIZE,

   462

	};

   463

   464

    // XXX: do we need a temp. copy? I think not

   465

	GRFConfig *list;       ///< temporary grf list to which changes are made

   466

	const GRFConfig *sel;

   467

   468

	NewGRFDownloadWindow(const WindowDesc *desc, GRFConfig *list) : Window(desc, 0)

   469

	{

   470

        // resize magic

   471

		this->resize.step_height = 14;

   472

   473

        // the list of GRFs

   474

        this->list = list;

   475

   476

        // display window?

   477

		this->FindWindowPlacementAndResize(desc);

   478

   479

        // set up our own state

   480

		this->SetupDownloadNewGRFWindow();

   481

	}

   482

   483

	~NewGRFDownloadWindow()

   484

	{

   485

		/* Remove the temporary copy of grf-list used in window */

   486

		ClearGRFConfigList(&this->list);

   487

    }

   488

   489

    void SetupDownloadNewGRFWindow()

   490

	{

   491

		const GRFConfig *c;

   492

		int i;

   493

   494

        // count how many NewGRFs in our list

   495

		for (c = this->list, i = 0; c != NULL; c = c->next, i++) {}

   496

   497

        // something to do with vertical scrolling...

   498

		this->vscroll.cap = (this->widget[DNGRFS_FILE_LIST].bottom - this->widget[DNGRFS_FILE_LIST].top) / 14 + 1;

   499

		SetVScrollCount(this, i);

   500

   501

        // disable the "Check Available" button if there are no incompatible NewGRFs

   502

		this->SetWidgetDisabledState(DNGRFS_CHECK_AVAILABLE, (i == 0));

   503

   504

        // disable the "Download Available" button until we've checked for available NewGRFs