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 "core/game.h"

    16

#include "../functions.h"

    17

#include "../debug.h"

    18

#include "../window_func.h"

    19

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

    20

#include "../string_func.h"

    21

#include "../gfx_func.h"

    22

#include "../querystring_gui.h"

    23

#include "../sortlist_type.h"

    24

#include "../fileio.h"

    25

#include "../rev.h"

    26

    27

// XXX: ...

    28

#include <curl/curl.h>

    29

    30

#include "table/strings.h"

    31

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

    32

    33

static int _has_curl_init = 0;

    34

    35

static CURLcode do_init_curl () {

    36

    CURLcode err;

    37

    38

    if (!_has_curl_init) {

    39

        // XXX: be smarter about what to initialize

    40

        if ((err = curl_global_init(CURL_GLOBAL_ALL)))

    41

            return err;

    42

    43

        _has_curl_init = 1;

    44

    }

    45

    46

    return CURLE_OK;

    47

}

    48

    49

struct check_write_ctx {

    50

    char *buf;

    51

    size_t len;

    52

    size_t offset;

    53

};

    54

    55

#define QUERY_ITEM_SIZE (                   \

    56

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

    57

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

    58

          + 1   /* the ":" */               \

    59

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

    60

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

    61

        )

    62

    63

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

    64

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

    65

    66

    // total number of bytes

    73

    74

    // realloc if needed

    76

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

    77

    78

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

    79

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

    80

    ctx->offset += len;

    81

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

    82

    83

    return len;

    84

}

    85

    86

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

    87

 * the GRFConfigs that are avilable to GCS_AVAILABLE

    88

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

    89

static int CheckAvailableNewGRFs(GRFConfig *list)

    90

{

    91

    GRFConfig *c;

    92

    int i;

    93

    char md5buf[64];

    94

    struct check_write_ctx write_ctx;

    95

    CURL *curl;

    96

    char api_url[512], useragent[512];

    97

    char curl_errbuf[CURL_ERROR_SIZE];

    98

    long http_code;

    99

    char *buf_ptr;

   100

    CURLcode err;

   101

    int ret = -1;

   102

    int found = 0;

   103

   104

    // initialize to a safe state for error handling

   105

    curl = write_ctx.buf = NULL;

   106

   107

    // count how many NewGRFs in our list

   108

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

   109

   110

    // how many bytes these take up...

   111

    int query_size = i * QUERY_ITEM_SIZE;

   112

   113

    // allocate the buffer for the query data

   114

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

   115

   116

    // build the query

   117

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

   118

   119

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

   120

        if (c != list)

   121

            *(query_ptr++) = '&';

   122

   123

        // format the md5sum

   124

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

   125

   126

        // snprintf the entry into the query buffer

   127

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

   128

   129

        // advance the query_ptr to point at the nul byte

   130

        query_ptr += QUERY_ITEM_SIZE - 1;

   131

    }

   132

   133

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

   134

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

   135

   136

    // our useragent

   137

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

   138

   139

    // receiving is so damn hard...

   140

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

   141

    write_ctx.len = 512;

   142

    write_ctx.offset = 0;

   143

   144

    // set up curl globally if needed

   145

    if ((err = do_init_curl())) {

   146

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

   147

        goto error;

   148

    }

   149

   150

    // allocate a new curl_easy

   151

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

   152

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

   153

        goto error;

   154

    }

   155

   156

    // let's set some options...

   157

    if (

   158

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

   159

    /*            

   160

            curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, XXX)

   161

    */            

   162

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

   163

        ||  (CURLE_OK != (err = curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_errbuf)))  // XXX: human-readable error messages

   164

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

   165

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

   166

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

   167

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

   168

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

   169

    ) {

   170

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

   171

        goto error;

   172

    }

   173

   174

    // XXX: currently this freezes the UI..

   175

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

   176

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

   177

        goto error;

   178

    }

   179

   180

    // get the HTTP return code

   181

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

   182

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

   183

        goto error;

   184

    }

   185

   186

    if (http_code != 200) {

   187

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

   188

        goto error;

   189

    }

   190

   191

    // start parsing...

   192

    buf_ptr = write_ctx.buf;

   193

   194

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

   195

        // replace the \n with a \0

   196

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

   197

   198

        if (!nl) {

   199

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

   200

            goto error;

   201

        }

   202

   203

        *nl = '\0';

   204

   205

        // check the format

   206

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

   207

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

   208

            goto error;

   209

        }

   210

   211

        // separate out the fields

   212

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

   213

   214

        // parse the GRFID...

   215

        char *invalid;

   216

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

   217

   218

        if (*invalid) {

   219

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

   220

            goto error;

   221

        }

   222

   223

        // parse the md5sum

   224

        uint8 md5sum[16]; 

   225

   226

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

   227

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

   228

            goto error;

   229

        }

   230

   231

        // copy the URL

   232

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

   233

   234

        // look for the GRF

   235

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

   236

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

   237

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

   238

   239

                c->filename = url;

   240

                c->status = GCS_AVAILABLE;

   241

                ClrBit(c->status, GCF_COMPATIBLE);

   242

   243

                found++;

   244

   245

                break;

   246

            } 

   247

        }

   248

   249

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

   250

        if (c == NULL) {

   251

            free(url);

   252

        }

   253

   254

        // move on to the next line

   255

        buf_ptr = nl + 1;

   256

    }

   257

   258

    // return number of NewGRFs found, defaults to -1 for errors

   259

    ret = found;    

   260

   261

error :

   262

    // cleanup

   263

    free(write_ctx.buf);

   264

   265

    if (curl)

   266

        curl_easy_cleanup(curl);

   267

   268

    // return as defined by ret

   269

    return ret;

   270

}

   271

   272

/** Download the NewGRFs that are listed as GCS_AVAILABLE

   273

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

   274

static int DownloadAvailableNewGRFs(GRFConfig *list)

   275

{

   276

    GRFConfig *c;

   277

    CURL *curl = NULL;

   278

    CURLcode err;

   279

    FILE *fh = NULL;

   280

    char md5buf[64], filename[256], useragent[512];

   281

    long http_code;

   282

    int ret = -1;

   283

    int found = 0;

   284

   285

    // set up curl

   286

    if ((err = do_init_curl())) {

   287

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

   288

        goto error;

   289

    }

   290

   291

    // allocate a new curl_easy

   292

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

   293

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

   294

        goto error;

   295

    }

   296

   297

    // our useragent

   298

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

   299

   300

    // let's set some options...

   301

    if (

   302

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

   303

    /*            

   304

            curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, XXX)

   305

    */            

   306

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

   307

//        ||  (CURLE_OK != (err = curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_errbuf)))  // human-readable error messages

   308

   309

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

   310

   311

/*       

   312

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

   313

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

   314

*/        

   315

    ) {

   316

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

   317

        goto error;

   318

    }

   319

   320

    // then start looping through the NewGRFs to download

   321

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

   322

        // skip the ones that are not available

   323

        if (c->status != GCS_AVAILABLE) 

   324

            continue;

   325

   326

        // format the md5sum

   327

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

   328

   329

        // snprintf the entry into the query buffer

   330

        assert(snprintf(filename, sizeof(filename), "%08X-%32s.tar", BSWAP32(c->grfid), md5buf) < 256);

   331

   332

        // open the file

   333

        if ((fh = FioFOpenFile(filename, "wb", CACHE_DIR)) == NULL) {

   334

            DEBUG(grfdl, 0, "Opening local GRF file failed: %s", filename);

   335

            goto error;

   336

        }

   337

   338

        // set up curl

   339

        if (

   340

                (CURLE_OK != (err = curl_easy_setopt(curl, CURLOPT_URL, c->filename)))              // the URL to retrieve

   341

            ||  (CURLE_OK != (err = curl_easy_setopt(curl, CURLOPT_WRITEDATA, fh)))                 // XXX: need to fwrite() ourself

   342

        ) {

   343

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

   344

            goto error;

   345

        }

   346

   347

        // XXX: currently this freezes the UI..

   348

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

   349

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

   350

            goto error;

   351

        }

   352

   353

        // get the HTTP return code

   354

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

   355

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

   356

            goto error;

   357

        }

   358

   359

        if (http_code != 200) {

   360

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

   361

            goto error;

   362

        }

   363

   364

        // OK, great

   365

        c->status = GCS_UNKNOWN;

   366

        ClrBit(c->status, GCF_COMPATIBLE);

   367

   368

        found++;

   369

    }

   370

   371

    // success

   372

    ret = found;

   373

   374

error:

   375

    if (fh)

   376

        fclose(fh);

   377

   378

    if (curl)

   379

        curl_easy_cleanup(curl);

   380

   381

    return ret;    

   382

}

   383

   384

// XXX: copy-pasted from newgrf_gui.cpp

   385

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

   386

{

   387

	char buff[256];

   388

   389

	if (c->error != NULL) {

   390

		char message[512];

   391

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

   392

			SetDParamStr(0, c->filename);

   393

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

   394

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

   395

				uint32 param = 0;

   396

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

   397

   398

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

   399

   400

				SetDParam(2 + i, param);

   401

			}

   402

   403

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

   404

		} else {

   405

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

   406

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

   407

		}

   408

   409

		SetDParamStr(0, message);

   410

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

   411

	}

   412

   413

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

   414

	if (c->filename != NULL) {

   415

		SetDParamStr(0, c->filename);

   416

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

   417

	}

   418

   419

	/* Prepare and draw GRF ID */

   420

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

   421

	SetDParamStr(0, buff);

   422

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

   423

   424

	/* Prepare and draw MD5 sum */

   425

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

   426

	SetDParamStr(0, buff);

   427

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

   428

   429

	/* Show GRF parameter list */

   430

	if (show_params) {

   431

		if (c->num_params > 0) {

   432

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

   433

			SetDParam(0, STR_JUST_RAW_STRING);

   434

			SetDParamStr(1, buff);

   435

		} else {

   436

			SetDParam(0, STR_01A9_NONE);

   437

		}

   438

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

   439

	}

   440

   441

	/* Show flags */

   442

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

   443

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

   444

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

   445

   446

	/* Draw GRF info if it exists */

   447

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

   448

		SetDParam(0, STR_JUST_RAW_STRING);

   449

		SetDParamStr(1, c->info);

   450

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

   451

	} else {

   452

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

   453

	}

   454

}

   455

   456

/**

   457

 * Window for downloading NewGRF files

   458

 */

   459

struct NewGRFDownloadWindow : public Window {

   460

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

   461

	enum DownloadNewGRFWindowWidgets {

   462

        DNGRFS_CLOSEBOX = 0,

   463

		DNGRFS_CAPTION,

   464

		DNGRFS_BACKGROUND,

   465

		DNGRFS_FILE_LIST,

   466

		DNGRFS_SCROLLBAR,

   467

		DNGRFS_NEWGRF_INFO,

   468

		DNGRFS_CHECK_AVAILABLE,

   469

		DNGRFS_DOWNLOAD_AVAILABLE,

   470

		DNGRFS_RESIZE,

   471

	};

   472

   473

    struct NetworkGameInfo *info;   ///< the server we are downloading NewGRFs for

   474

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

   475

	const GRFConfig *sel;

   476

   477

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

   478

	{

   479

        // resize magic

   480

		this->resize.step_height = 14;

   481

   482

        // the server info

   483

        this->info = info;

   484

   485

        // the list of GRFs that we need

   486

        this->list = list;

   487

   488

        // display window?

   489

		this->FindWindowPlacementAndResize(desc);

   490

   491

        // set up our own state

   492

		this->SetupDownloadNewGRFWindow();

   493

	}

   494

   495

	~NewGRFDownloadWindow()

   496

	{

   497

        // Apply changes from list to the config

   498

        GRFConfig *config, *list;

   499

   500

        // default to true, set back to false if we find a still-missing NewGRF

   501

        this->info->compatible = true;

   502