← Back to branch summary

~ubuntu-branches/debian/sid/freeciv/sid

« back to all changes in this revision

Viewing changes to server/notify.c

  • Committer: Package Import Robot
  • Author(s): Clint Adams, Karl Goetz, Clint Adams
  • Date: 2011-08-28 22:40:00 UTC
  • mfrom: (1.2.19 upstream)
  • Revision ID: package-import@ubuntu.com-20110828224000-j2r1erewlem25dox
Tags: 2.3.0-1
[ Karl Goetz ]
* New upstream version.
* Fix themes_sdl_use_system_fonts.diff to apply cleanly on 2.3.0
* Massage work_around_unity_induced_breakage.diff to get it
  applying to the new codebase (The patch assumes commits made
  after 2.3.0 was tagged upstream).

[ Clint Adams ]
* Fudge build system to think there is no libtool mismatch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/notify.c
18
18
#include <stdarg.h>
19
19
 
20
20
/* utility */
 
21
#include "bitvector.h"
21
22
#include "log.h"
22
23
#include "registry.h"
23
24
 
26
27
#include "events.h"
27
28
#include "featured_text.h"
28
29
#include "game.h"
 
30
#include "research.h"
29
31
#include "packets.h"
30
32
#include "player.h"
31
33
#include "tile.h"
57
59
                               const struct ft_color color,
58
60
                               const char *format, va_list vargs)
59
61
{
60
 
  RETURN_IF_FAIL(NULL != packet);
 
62
  fc_assert_ret(NULL != packet);
61
63
 
62
 
  if (ptile) {
63
 
    packet->x = ptile->x;
64
 
    packet->y = ptile->y;
65
 
  } else {
66
 
    packet->x = -1;
67
 
    packet->y = -1;
68
 
  }
 
64
  packet->tile = (NULL != ptile ? tile_index(ptile) : -1);
69
65
  packet->event = event;
70
66
  packet->conn_id = pconn ? pconn->id : -1;
71
67
 
73
69
    /* A color is requested. */
74
70
    char buf[MAX_LEN_MSG];
75
71
 
76
 
    my_vsnprintf(buf, sizeof(buf), format, vargs);
 
72
    fc_vsnprintf(buf, sizeof(buf), format, vargs);
77
73
    featured_text_apply_tag(buf, packet->message, sizeof(packet->message),
78
74
                            TTT_COLOR, 0, FT_OFFSET_UNSET, color);
79
75
  } else {
80
76
    /* Simple case */
81
 
    my_vsnprintf(packet->message, sizeof(packet->message), format, vargs);
 
77
    fc_vsnprintf(packet->message, sizeof(packet->message), format, vargs);
82
78
  }
83
79
}
84
80
 
186
182
                               const struct packet_chat_msg *packet)
187
183
{
188
184
  struct packet_chat_msg real_packet = *packet;
189
 
  struct tile *ptile;
 
185
  int tile = packet->tile;
 
186
  struct tile *ptile = index_to_tile(tile);
190
187
 
191
188
  if (!dest) {
192
189
    dest = game.est_connections;
193
190
  }
194
191
 
195
 
  if (is_normal_map_pos(packet->x, packet->y)) {
196
 
    ptile = map_pos_to_tile(packet->x, packet->y);
197
 
  } else {
198
 
    ptile = NULL;
199
 
  }
200
 
 
201
192
  conn_list_iterate(dest, pconn) {
202
193
    /* Avoid sending messages that could potentially reveal
203
194
     * internal information about the server machine to
212
203
        && ((NULL == pconn->playing && pconn->observer)
213
204
            || (NULL != pconn->playing
214
205
                && map_is_known(ptile, pconn->playing)))) {
215
 
      /* coordinates are OK; see above */
216
 
      real_packet.x = ptile->x;
217
 
      real_packet.y = ptile->y;
 
206
      /* tile info is OK; see above. */
 
207
      /* FIXME: in the case this is a city event, we should check if the
 
208
       * city is really known. */
 
209
      real_packet.tile = tile;
218
210
    } else {
219
 
      /* no coordinates */
220
 
      assert(S_S_RUNNING > server_state() || !is_normal_map_pos(-1, -1));
221
 
      real_packet.x = -1;
222
 
      real_packet.y = -1;
 
211
      /* No tile info. */
 
212
      real_packet.tile = -1;
223
213
    }
224
214
 
225
215
    send_packet_chat_msg(pconn, &real_packet);
351
341
  notify_conn_packet(dest, &genmsg);
352
342
 
353
343
  if (pplayer) {
354
 
    conn_list_free(dest);
 
344
    conn_list_destroy(dest);
355
345
  }
356
346
}
357
347
 
370
360
  struct packet_chat_msg genmsg;
371
361
  struct event_cache_players *players = NULL;
372
362
  va_list args;
373
 
  struct player_research *research = get_player_research(pplayer);
 
363
  struct player_research *research = player_research_get(pplayer);
374
364
 
375
365
  va_start(args, format);
376
366
  vpackage_event(&genmsg, NULL, event, color, format, args);
377
367
  va_end(args);
378
368
 
379
369
  players_iterate(other_player) {
380
 
    if (get_player_research(other_player) == research) {
 
370
    if (player_research_get(other_player) == research) {
381
371
      lsend_packet_chat_msg(other_player->connections, &genmsg);
382
372
      players = event_cache_player_add(players, other_player);
383
373
    }
430
420
**************************************************************************/
431
421
static void event_cache_data_destroy(struct event_cache_data *pdata)
432
422
{
433
 
  RETURN_IF_FAIL(NULL != event_cache);
434
 
  RETURN_IF_FAIL(NULL != pdata);
 
423
  fc_assert_ret(NULL != event_cache);
 
424
  fc_assert_ret(NULL != pdata);
435
425
 
436
 
  event_cache_data_list_unlink(event_cache, pdata);
 
426
  event_cache_data_list_remove(event_cache, pdata);
437
427
  free(pdata);
438
428
}
439
429
 
455
445
     * recursion. */
456
446
    return NULL;
457
447
  }
458
 
  RETURN_VAL_IF_FAIL(NULL != packet, NULL);
 
448
  fc_assert_ret_val(NULL != packet, NULL);
459
449
 
460
450
  if (packet->event == E_MESSAGE_WALL) {
461
451
    /* No popups at save game load. */
516
506
    event_cache_iterate(pdata) {
517
507
      event_cache_data_destroy(pdata);
518
508
    } event_cache_iterate_end;
519
 
    event_cache_data_list_free(event_cache);
 
509
    event_cache_data_list_destroy(event_cache);
520
510
    event_cache = NULL;
521
511
  }
522
512
  event_cache_status = FALSE;
587
577
 
588
578
    pdata = event_cache_data_new(packet, game.info.turn, time(NULL),
589
579
                                 server_state(), ECT_PLAYERS, NULL);
590
 
    RETURN_IF_FAIL(NULL != pdata);
 
580
    fc_assert_ret(NULL != pdata);
591
581
    BV_SET(pdata->target, player_index(pplayer));
592
582
  }
593
583
}
696
686
        strftime(timestr, sizeof(timestr), "%H:%M:%S",
697
687
                 localtime(&pdata->timestamp));
698
688
        pcm = pdata->packet;
699
 
        my_snprintf(pcm.message, sizeof(pcm.message), "(T%d - %s) %s",
 
689
        fc_snprintf(pcm.message, sizeof(pcm.message), "(T%d - %s) %s",
700
690
                    pdata->turn, timestr, pdata->packet.message);
701
691
        notify_conn_packet(pconn->self, &pcm);
702
692
      } else {
715
705
  enum event_cache_target target_type;
716
706
  enum server_states server_status;
717
707
  struct event_cache_players *players = NULL;
718
 
  int i, turn, event_count;
 
708
  int i, x, y, turn, event_count;
719
709
  time_t timestamp, now;
720
710
  const char *p, *q;
721
711
 
722
712
  event_count = secfile_lookup_int_default(file, 0, "%s.count", section);
723
 
  freelog(LOG_VERBOSE, "Saved events: %d.", event_count);
 
713
  log_verbose("Saved events: %d.", event_count);
724
714
 
725
715
  if (0 >= event_count) {
726
716
    return;
729
719
  now = time(NULL);
730
720
  for (i = 0; i < event_count; i++) {
731
721
    /* restore packet */
732
 
    packet.x = secfile_lookup_int_default(file, -1, "%s.events%d.x",
733
 
                                          section, i);
734
 
    packet.y = secfile_lookup_int_default(file, -1, "%s.events%d.y",
735
 
                                          section, i);
 
722
    x = secfile_lookup_int_default(file, -1, "%s.events%d.x", section, i);
 
723
    y = secfile_lookup_int_default(file, -1, "%s.events%d.y", section, i);
 
724
    packet.tile = (is_normal_map_pos(x, y) ? map_pos_to_index(x, y) : -1);
736
725
    packet.conn_id = -1;
737
726
 
738
727
    p = secfile_lookup_str(file, "%s.events%d.event", section, i);
739
728
    if (NULL == p) {
740
 
      freelog(LOG_ERROR, "[Event cache %4d] Missing event type.", i);
 
729
      log_verbose("[Event cache %4d] Missing event type.", i);
741
730
      continue;
742
731
    }
743
 
    packet.event = event_type_by_name(p, mystrcasecmp);
 
732
    packet.event = event_type_by_name(p, fc_strcasecmp);
744
733
    if (!event_type_is_valid(packet.event)) {
745
 
      freelog(LOG_ERROR, "[Event cache %4d] Not supported event type: %s",
746
 
              i, p);
 
734
      log_verbose("[Event cache %4d] Not supported event type: %s", i, p);
747
735
      continue;
748
736
    }
749
737
 
750
738
    p = secfile_lookup_str(file, "%s.events%d.message", section, i);
751
739
    if (NULL == p) {
752
 
      freelog(LOG_ERROR, "[Event cache %4d] Missing message.", i);
 
740
      log_verbose("[Event cache %4d] Missing message.", i);
753
741
      continue;
754
742
    }
755
743
    sz_strlcpy(packet.message, p);
763
751
 
764
752
    p = secfile_lookup_str(file, "%s.events%d.server_state", section, i);
765
753
    if (NULL == p) {
766
 
      freelog(LOG_ERROR, "[Event cache %4d] Missing server state info.", i);
 
754
      log_verbose("[Event cache %4d] Missing server state info.", i);
767
755
      continue;
768
756
    }
769
 
    server_status = server_states_by_name(p, mystrcasecmp);
 
757
    server_status = server_states_by_name(p, fc_strcasecmp);
770
758
    if (!server_states_is_valid(server_status)) {
771
 
      freelog(LOG_ERROR, "[Event cache %4d] Server state no supported: %s",
772
 
              i, p);
 
759
      log_verbose("[Event cache %4d] Server state no supported: %s", i, p);
773
760
      continue;
774
761
    }
775
762
 
776
763
    p = secfile_lookup_str(file, "%s.events%d.target", section, i);
777
764
    if (NULL == p) {
778
 
      freelog(LOG_ERROR, "[Event cache %4d] Missing target info.", i);
 
765
      log_verbose("[Event cache %4d] Missing target info.", i);
779
766
      continue;
780
 
    } else if (0 == mystrcasecmp(p, "All")) {
 
767
    } else if (0 == fc_strcasecmp(p, "All")) {
781
768
      target_type = ECT_ALL;
782
 
    } else if (0 == mystrcasecmp(p, "Global Observers")) {
 
769
    } else if (0 == fc_strcasecmp(p, "Global Observers")) {
783
770
      target_type = ECT_GLOBAL_OBSERVERS;
784
771
    } else {
785
772
      bool valid = TRUE;
799
786
      } players_iterate_end;
800
787
 
801
788
      if (!valid && NULL == players) {
802
 
        freelog(LOG_ERROR, "[Event cache %4d] invalid target bitmap: %s",
803
 
                i, p);
 
789
        log_verbose("[Event cache %4d] invalid target bitmap: %s", i, p);
804
790
        if (NULL != players) {
805
791
          FC_FREE(players);
806
792
        }
816
802
      FC_FREE(players);
817
803
    }
818
804
 
819
 
    freelog(LOG_VERBOSE, "Event %4d loaded.", i);
 
805
    log_verbose("Event %4d loaded.", i);
820
806
  }
821
807
}
822
808
 
825
811
***************************************************************/
826
812
void event_cache_save(struct section_file *file, const char *section)
827
813
{
 
814
  struct tile *ptile;
828
815
  int event_count = 0;
829
 
  char target[MAX_NUM_PLAYERS + MAX_NUM_BARBARIANS + 1];
 
816
  char target[MAX_NUM_PLAYER_SLOTS + 1];
830
817
  char *p;
831
818
 
832
 
  /* stop event logging; this way events from freelog() will not be added
 
819
  /* stop event logging; this way events from log_*() will not be added
833
820
   * to the event list while saving the event list */
834
821
  event_cache_status = FALSE;
835
822
 
836
823
  event_cache_iterate(pdata) {
 
824
    ptile = index_to_tile(pdata->packet.tile);
837
825
    secfile_insert_int(file, pdata->turn, "%s.events%d.turn",
838
826
                       section, event_count);
839
827
    secfile_insert_int(file, pdata->timestamp, "%s.events%d.timestamp",
840
828
                       section, event_count);
841
 
    secfile_insert_int(file, pdata->packet.x, "%s.events%d.x",
842
 
                       section, event_count);
843
 
    secfile_insert_int(file, pdata->packet.y, "%s.events%d.y",
844
 
                       section, event_count);
 
829
    secfile_insert_int(file, NULL != ptile ? ptile->x : -1,
 
830
                       "%s.events%d.x", section, event_count);
 
831
    secfile_insert_int(file, NULL != ptile ? ptile->y : -1,
 
832
                       "%s.events%d.y", section, event_count);
845
833
    secfile_insert_str(file, server_states_name(pdata->server_state),
846
834
                       "%s.events%d.server_state", section, event_count);
847
835
    secfile_insert_str(file, event_type_name(pdata->packet.event),
848
836
                       "%s.events%d.event", section, event_count);
849
837
    switch (pdata->target_type) {
850
838
    case ECT_ALL:
851
 
      my_snprintf(target, sizeof(target), "All");
 
839
      fc_snprintf(target, sizeof(target), "All");
852
840
      break;
853
841
    case ECT_PLAYERS:
854
842
      p = target;
858
846
      *p = '\0';
859
847
    break;
860
848
    case ECT_GLOBAL_OBSERVERS:
861
 
      my_snprintf(target, sizeof(target), "Global Observers");
 
849
      fc_snprintf(target, sizeof(target), "Global Observers");
862
850
      break;
863
851
    }
864
852
    secfile_insert_str(file, target, "%s.events%d.target",
866
854
    secfile_insert_str(file, pdata->packet.message, "%s.events%d.message",
867
855
                       section, event_count);
868
856
 
869
 
    freelog(LOG_VERBOSE, "Event %4d saved.", event_count);
 
857
    log_verbose("Event %4d saved.", event_count);
870
858
 
871
859
    event_count++;
872
860
  } event_cache_iterate_end;
874
862
  /* save the number of events in the event cache */
875
863
  secfile_insert_int(file, event_count, "%s.count", section);
876
864
 
877
 
  freelog(LOG_VERBOSE, "Events saved: %d.", event_count);
 
865
  log_verbose("Events saved: %d.", event_count);
878
866
 
879
867
  event_cache_status = TRUE;
880
868
}